X-Git-Url: https://git.r.bdr.sh/rbdr/mobius/blobdiff_plain/84f3e842cefd5d56bfad299c9592d836dc13059a..4fa4a57c4352f703958c3c5cb8dcd2b56cb35882:/hotline/transaction_handlers_test.go diff --git a/hotline/transaction_handlers_test.go b/hotline/transaction_handlers_test.go index b03e3b1..610e113 100644 --- a/hotline/transaction_handlers_test.go +++ b/hotline/transaction_handlers_test.go @@ -2,11 +2,10 @@ package hotline import ( "errors" - "fmt" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/mock" + "io" "io/fs" - "math/rand" "os" "path/filepath" "strings" @@ -17,13 +16,12 @@ import ( func TestHandleSetChatSubject(t *testing.T) { type args struct { cc *ClientConn - t *Transaction + t Transaction } tests := []struct { - name string - args args - want []Transaction - wantErr bool + name string + args args + want []Transaction }{ { name: "sends chat subject to private chat members", @@ -31,47 +29,68 @@ func TestHandleSetChatSubject(t *testing.T) { cc: &ClientConn{ UserName: []byte{0x00, 0x01}, Server: &Server{ - PrivateChats: map[uint32]*PrivateChat{ - uint32(1): { - Subject: "unset", - ClientConn: map[uint16]*ClientConn{ - uint16(1): { - Account: &Account{ - Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255}, - }, - ID: &[]byte{0, 1}, + ChatMgr: func() *MockChatManager { + m := MockChatManager{} + m.On("Members", ChatID{0x0, 0x0, 0x0, 0x1}).Return([]*ClientConn{ + { + Account: &Account{ + Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255}, }, - uint16(2): { - Account: &Account{ - Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255}, - }, - ID: &[]byte{0, 2}, + ID: [2]byte{0, 1}, + }, + { + Account: &Account{ + Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255}, }, + ID: [2]byte{0, 2}, }, - }, - }, - Clients: map[uint16]*ClientConn{ - uint16(1): { - Account: &Account{ - Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255}, + }) + m.On("SetSubject", ChatID{0x0, 0x0, 0x0, 0x1}, "Test Subject") + return &m + }(), + //PrivateChats: map[[4]byte]*PrivateChat{ + // [4]byte{0, 0, 0, 1}: { + // Subject: "unset", + // ClientConn: map[[2]byte]*ClientConn{ + // [2]byte{0, 1}: { + // Account: &Account{ + // Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255}, + // }, + // ID: [2]byte{0, 1}, + // }, + // [2]byte{0, 2}: { + // Account: &Account{ + // Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255}, + // }, + // ID: [2]byte{0, 2}, + // }, + // }, + // }, + //}, + ClientMgr: func() *MockClientMgr { + m := MockClientMgr{} + m.On("List").Return([]*ClientConn{ + { + Account: &Account{ + Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255}, + }, + ID: [2]byte{0, 1}, }, - ID: &[]byte{0, 1}, - }, - uint16(2): { - Account: &Account{ - Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255}, + { + Account: &Account{ + Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255}, + }, + ID: [2]byte{0, 2}, }, - ID: &[]byte{0, 2}, }, - }, + ) + return &m + }(), }, }, - t: &Transaction{ - Flags: 0x00, - IsReply: 0x00, - Type: []byte{0, 0x6a}, - ID: []byte{0, 0, 0, 1}, - ErrorCode: []byte{0, 0, 0, 0}, + t: Transaction{ + Type: [2]byte{0, 0x6a}, + ID: [4]byte{0, 0, 0, 1}, Fields: []Field{ NewField(FieldChatID, []byte{0, 0, 0, 1}), NewField(FieldChatSubject, []byte("Test Subject")), @@ -80,43 +99,28 @@ func TestHandleSetChatSubject(t *testing.T) { }, want: []Transaction{ { - clientID: &[]byte{0, 1}, - Flags: 0x00, - IsReply: 0x00, - Type: []byte{0, 0x77}, - ID: []byte{0x9a, 0xcb, 0x04, 0x42}, // Random ID from rand.Seed(1) - ErrorCode: []byte{0, 0, 0, 0}, + clientID: [2]byte{0, 1}, + Type: [2]byte{0, 0x77}, Fields: []Field{ NewField(FieldChatID, []byte{0, 0, 0, 1}), NewField(FieldChatSubject, []byte("Test Subject")), }, }, { - clientID: &[]byte{0, 2}, - Flags: 0x00, - IsReply: 0x00, - Type: []byte{0, 0x77}, - ID: []byte{0xf0, 0xc5, 0x34, 0x1e}, // Random ID from rand.Seed(1) - ErrorCode: []byte{0, 0, 0, 0}, + clientID: [2]byte{0, 2}, + Type: [2]byte{0, 0x77}, Fields: []Field{ NewField(FieldChatID, []byte{0, 0, 0, 1}), NewField(FieldChatSubject, []byte("Test Subject")), }, }, }, - wantErr: false, }, } for _, tt := range tests { - rand.Seed(1) // reset seed between tests to make transaction IDs predictable - t.Run(tt.name, func(t *testing.T) { - got, err := HandleSetChatSubject(tt.args.cc, tt.args.t) - if (err != nil) != tt.wantErr { - t.Errorf("HandleSetChatSubject() error = %v, wantErr %v", err, tt.wantErr) - return - } - if !assert.Equal(t, tt.want, got) { + got := HandleSetChatSubject(tt.args.cc, &tt.args.t) + if !tranAssertEqual(t, tt.want, got) { t.Errorf("HandleSetChatSubject() got = %v, want %v", got, tt.want) } }) @@ -126,82 +130,72 @@ func TestHandleSetChatSubject(t *testing.T) { func TestHandleLeaveChat(t *testing.T) { type args struct { cc *ClientConn - t *Transaction + t Transaction } tests := []struct { - name string - args args - want []Transaction - wantErr bool + name string + args args + want []Transaction }{ { - name: "returns expected transactions", + name: "when client 2 leaves chat", args: args{ cc: &ClientConn{ - ID: &[]byte{0, 2}, + ID: [2]byte{0, 2}, Server: &Server{ - PrivateChats: map[uint32]*PrivateChat{ - uint32(1): { - ClientConn: map[uint16]*ClientConn{ - uint16(1): { - Account: &Account{ - Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255}, - }, - ID: &[]byte{0, 1}, - }, - uint16(2): { - Account: &Account{ - Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255}, - }, - ID: &[]byte{0, 2}, + ChatMgr: func() *MockChatManager { + m := MockChatManager{} + m.On("Members", ChatID{0x0, 0x0, 0x0, 0x1}).Return([]*ClientConn{ + { + Account: &Account{ + Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255}, }, + ID: [2]byte{0, 1}, }, - }, - }, - Clients: map[uint16]*ClientConn{ - uint16(1): { - Account: &Account{ - Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255}, + }) + m.On("Leave", ChatID{0x0, 0x0, 0x0, 0x1}, [2]uint8{0x0, 0x2}) + m.On("GetSubject").Return("unset") + return &m + }(), + ClientMgr: func() *MockClientMgr { + m := MockClientMgr{} + m.On("Get").Return([]*ClientConn{ + { + Account: &Account{ + Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255}, + }, + ID: [2]byte{0, 1}, }, - ID: &[]byte{0, 1}, - }, - uint16(2): { - Account: &Account{ - Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255}, + { + Account: &Account{ + Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255}, + }, + ID: [2]byte{0, 2}, }, - ID: &[]byte{0, 2}, }, - }, + ) + return &m + }(), }, }, - t: NewTransaction(TranDeleteUser, nil, NewField(FieldChatID, []byte{0, 0, 0, 1})), + t: NewTransaction(TranDeleteUser, [2]byte{}, NewField(FieldChatID, []byte{0, 0, 0, 1})), }, want: []Transaction{ { - clientID: &[]byte{0, 1}, - Flags: 0x00, - IsReply: 0x00, - Type: []byte{0, 0x76}, - ID: []byte{0x9a, 0xcb, 0x04, 0x42}, // Random ID from rand.Seed(1) - ErrorCode: []byte{0, 0, 0, 0}, + clientID: [2]byte{0, 1}, + Type: [2]byte{0, 0x76}, Fields: []Field{ NewField(FieldChatID, []byte{0, 0, 0, 1}), NewField(FieldUserID, []byte{0, 2}), }, }, }, - wantErr: false, }, } for _, tt := range tests { - rand.Seed(1) t.Run(tt.name, func(t *testing.T) { - got, err := HandleLeaveChat(tt.args.cc, tt.args.t) - if (err != nil) != tt.wantErr { - t.Errorf("HandleLeaveChat() error = %v, wantErr %v", err, tt.wantErr) - return - } - if !assert.Equal(t, tt.want, got) { + got := HandleLeaveChat(tt.args.cc, &tt.args.t) + if !tranAssertEqual(t, tt.want, got) { t.Errorf("HandleLeaveChat() got = %v, want %v", got, tt.want) } }) @@ -211,50 +205,46 @@ func TestHandleLeaveChat(t *testing.T) { func TestHandleGetUserNameList(t *testing.T) { type args struct { cc *ClientConn - t *Transaction + t Transaction } tests := []struct { - name string - args args - want []Transaction - wantErr bool + name string + args args + want []Transaction }{ { name: "replies with userlist transaction", args: args{ cc: &ClientConn{ - - ID: &[]byte{1, 1}, + ID: [2]byte{0, 1}, Server: &Server{ - Clients: map[uint16]*ClientConn{ - uint16(1): { - ID: &[]byte{0, 1}, - Icon: []byte{0, 2}, - Flags: []byte{0, 3}, - UserName: []byte{0, 4}, - }, - uint16(2): { - ID: &[]byte{0, 2}, - Icon: []byte{0, 2}, - Flags: []byte{0, 3}, - UserName: []byte{0, 4}, + ClientMgr: func() *MockClientMgr { + m := MockClientMgr{} + m.On("List").Return([]*ClientConn{ + { + ID: [2]byte{0, 1}, + Icon: []byte{0, 2}, + Flags: [2]byte{0, 3}, + UserName: []byte{0, 4}, + }, + { + ID: [2]byte{0, 2}, + Icon: []byte{0, 2}, + Flags: [2]byte{0, 3}, + UserName: []byte{0, 4}, + }, }, - }, + ) + return &m + }(), }, }, - t: &Transaction{ - ID: []byte{0, 0, 0, 1}, - Type: []byte{0, 1}, - }, + t: Transaction{}, }, want: []Transaction{ { - clientID: &[]byte{1, 1}, - Flags: 0x00, - IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0, 0, 0, 1}, - ErrorCode: []byte{0, 0, 0, 0}, + clientID: [2]byte{0, 1}, + IsReply: 0x01, Fields: []Field{ NewField( FieldUsernameWithInfo, @@ -267,16 +257,11 @@ func TestHandleGetUserNameList(t *testing.T) { }, }, }, - wantErr: false, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - got, err := HandleGetUserNameList(tt.args.cc, tt.args.t) - if (err != nil) != tt.wantErr { - t.Errorf("HandleGetUserNameList() error = %v, wantErr %v", err, tt.wantErr) - return - } + got := HandleGetUserNameList(tt.args.cc, &tt.args.t) assert.Equal(t, tt.want, got) }) } @@ -285,13 +270,12 @@ func TestHandleGetUserNameList(t *testing.T) { func TestHandleChatSend(t *testing.T) { type args struct { cc *ClientConn - t *Transaction + t Transaction } tests := []struct { - name string - args args - want []Transaction - wantErr bool + name string + args args + want []Transaction }{ { name: "sends chat msg transaction to all clients", @@ -300,29 +284,34 @@ func TestHandleChatSend(t *testing.T) { Account: &Account{ Access: func() accessBitmap { var bits accessBitmap - bits.Set(accessSendChat) + bits.Set(AccessSendChat) return bits }(), }, UserName: []byte{0x00, 0x01}, Server: &Server{ - Clients: map[uint16]*ClientConn{ - uint16(1): { - Account: &Account{ - Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255}, + ClientMgr: func() *MockClientMgr { + m := MockClientMgr{} + m.On("List").Return([]*ClientConn{ + { + Account: &Account{ + Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255}, + }, + ID: [2]byte{0, 1}, }, - ID: &[]byte{0, 1}, - }, - uint16(2): { - Account: &Account{ - Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255}, + { + Account: &Account{ + Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255}, + }, + ID: [2]byte{0, 2}, }, - ID: &[]byte{0, 2}, }, - }, + ) + return &m + }(), }, }, - t: &Transaction{ + t: Transaction{ Fields: []Field{ NewField(FieldData, []byte("hai")), }, @@ -330,60 +319,60 @@ func TestHandleChatSend(t *testing.T) { }, want: []Transaction{ { - clientID: &[]byte{0, 1}, - Flags: 0x00, - IsReply: 0x00, - Type: []byte{0, 0x6a}, - ID: []byte{0x9a, 0xcb, 0x04, 0x42}, // Random ID from rand.Seed(1) - ErrorCode: []byte{0, 0, 0, 0}, + clientID: [2]byte{0, 1}, + Flags: 0x00, + IsReply: 0x00, + Type: [2]byte{0, 0x6a}, Fields: []Field{ NewField(FieldData, []byte{0x0d, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x01, 0x3a, 0x20, 0x20, 0x68, 0x61, 0x69}), }, }, { - clientID: &[]byte{0, 2}, - Flags: 0x00, - IsReply: 0x00, - Type: []byte{0, 0x6a}, - ID: []byte{0xf0, 0xc5, 0x34, 0x1e}, // Random ID from rand.Seed(1) - ErrorCode: []byte{0, 0, 0, 0}, + clientID: [2]byte{0, 2}, + Flags: 0x00, + IsReply: 0x00, + Type: [2]byte{0, 0x6a}, Fields: []Field{ NewField(FieldData, []byte{0x0d, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x01, 0x3a, 0x20, 0x20, 0x68, 0x61, 0x69}), }, }, }, - wantErr: false, }, { - name: "treats Chat ID 00 00 00 00 as a public chat message", + name: "treats Chat Type 00 00 00 00 as a public chat message", args: args{ cc: &ClientConn{ Account: &Account{ Access: func() accessBitmap { var bits accessBitmap - bits.Set(accessSendChat) + bits.Set(AccessSendChat) return bits }(), }, UserName: []byte{0x00, 0x01}, Server: &Server{ - Clients: map[uint16]*ClientConn{ - uint16(1): { - Account: &Account{ - Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255}, + ClientMgr: func() *MockClientMgr { + m := MockClientMgr{} + m.On("List").Return([]*ClientConn{ + { + Account: &Account{ + Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255}, + }, + ID: [2]byte{0, 1}, }, - ID: &[]byte{0, 1}, - }, - uint16(2): { - Account: &Account{ - Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255}, + { + Account: &Account{ + Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255}, + }, + ID: [2]byte{0, 2}, }, - ID: &[]byte{0, 2}, }, - }, + ) + return &m + }(), }, }, - t: &Transaction{ + t: Transaction{ Fields: []Field{ NewField(FieldData, []byte("hai")), NewField(FieldChatID, []byte{0, 0, 0, 0}), @@ -392,29 +381,20 @@ func TestHandleChatSend(t *testing.T) { }, want: []Transaction{ { - clientID: &[]byte{0, 1}, - Flags: 0x00, - IsReply: 0x00, - Type: []byte{0, 0x6a}, - ID: []byte{0x9a, 0xcb, 0x04, 0x42}, // Random ID from rand.Seed(1) - ErrorCode: []byte{0, 0, 0, 0}, + clientID: [2]byte{0, 1}, + Type: [2]byte{0, 0x6a}, Fields: []Field{ NewField(FieldData, []byte{0x0d, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x01, 0x3a, 0x20, 0x20, 0x68, 0x61, 0x69}), }, }, { - clientID: &[]byte{0, 2}, - Flags: 0x00, - IsReply: 0x00, - Type: []byte{0, 0x6a}, - ID: []byte{0xf0, 0xc5, 0x34, 0x1e}, // Random ID from rand.Seed(1) - ErrorCode: []byte{0, 0, 0, 0}, + clientID: [2]byte{0, 2}, + Type: [2]byte{0, 0x6a}, Fields: []Field{ NewField(FieldData, []byte{0x0d, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x01, 0x3a, 0x20, 0x20, 0x68, 0x61, 0x69}), }, }, }, - wantErr: false, }, { name: "when user does not have required permission", @@ -427,27 +407,23 @@ func TestHandleChatSend(t *testing.T) { }(), }, Server: &Server{ - Accounts: map[string]*Account{}, + //Accounts: map[string]*Account{}, }, }, t: NewTransaction( - TranChatSend, &[]byte{0, 1}, + TranChatSend, [2]byte{0, 1}, NewField(FieldData, []byte("hai")), ), }, want: []Transaction{ { - Flags: 0x00, IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0x9a, 0xcb, 0x04, 0x42}, - ErrorCode: []byte{0, 0, 0, 1}, + ErrorCode: [4]byte{0, 0, 0, 1}, Fields: []Field{ NewField(FieldError, []byte("You are not allowed to participate in chat.")), }, }, }, - wantErr: false, }, { name: "sends chat msg as emote if FieldChatOptions is set to 1", @@ -456,29 +432,34 @@ func TestHandleChatSend(t *testing.T) { Account: &Account{ Access: func() accessBitmap { var bits accessBitmap - bits.Set(accessSendChat) + bits.Set(AccessSendChat) return bits }(), }, UserName: []byte("Testy McTest"), Server: &Server{ - Clients: map[uint16]*ClientConn{ - uint16(1): { - Account: &Account{ - Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255}, + ClientMgr: func() *MockClientMgr { + m := MockClientMgr{} + m.On("List").Return([]*ClientConn{ + { + Account: &Account{ + Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255}, + }, + ID: [2]byte{0, 1}, }, - ID: &[]byte{0, 1}, - }, - uint16(2): { - Account: &Account{ - Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255}, + { + Account: &Account{ + Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255}, + }, + ID: [2]byte{0, 2}, }, - ID: &[]byte{0, 2}, }, - }, + ) + return &m + }(), }, }, - t: &Transaction{ + t: Transaction{ Fields: []Field{ NewField(FieldData, []byte("performed action")), NewField(FieldChatOptions, []byte{0x00, 0x01}), @@ -487,29 +468,24 @@ func TestHandleChatSend(t *testing.T) { }, want: []Transaction{ { - clientID: &[]byte{0, 1}, - Flags: 0x00, - IsReply: 0x00, - Type: []byte{0, 0x6a}, - ID: []byte{0x9a, 0xcb, 0x04, 0x42}, - ErrorCode: []byte{0, 0, 0, 0}, + clientID: [2]byte{0, 1}, + Flags: 0x00, + IsReply: 0x00, + Type: [2]byte{0, 0x6a}, Fields: []Field{ NewField(FieldData, []byte("\r*** Testy McTest performed action")), }, }, { - clientID: &[]byte{0, 2}, - Flags: 0x00, - IsReply: 0x00, - Type: []byte{0, 0x6a}, - ID: []byte{0xf0, 0xc5, 0x34, 0x1e}, - ErrorCode: []byte{0, 0, 0, 0}, + clientID: [2]byte{0, 2}, + Flags: 0x00, + IsReply: 0x00, + Type: [2]byte{0, 0x6a}, Fields: []Field{ NewField(FieldData, []byte("\r*** Testy McTest performed action")), }, }, }, - wantErr: false, }, { name: "does not send chat msg as emote if FieldChatOptions is set to 0", @@ -518,29 +494,34 @@ func TestHandleChatSend(t *testing.T) { Account: &Account{ Access: func() accessBitmap { var bits accessBitmap - bits.Set(accessSendChat) + bits.Set(AccessSendChat) return bits }(), }, UserName: []byte("Testy McTest"), Server: &Server{ - Clients: map[uint16]*ClientConn{ - uint16(1): { - Account: &Account{ - Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255}, + ClientMgr: func() *MockClientMgr { + m := MockClientMgr{} + m.On("List").Return([]*ClientConn{ + { + Account: &Account{ + Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255}, + }, + ID: [2]byte{0, 1}, }, - ID: &[]byte{0, 1}, - }, - uint16(2): { - Account: &Account{ - Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255}, + { + Account: &Account{ + Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255}, + }, + ID: [2]byte{0, 2}, }, - ID: &[]byte{0, 2}, }, - }, + ) + return &m + }(), }, }, - t: &Transaction{ + t: Transaction{ Fields: []Field{ NewField(FieldData, []byte("hello")), NewField(FieldChatOptions, []byte{0x00, 0x00}), @@ -549,63 +530,58 @@ func TestHandleChatSend(t *testing.T) { }, want: []Transaction{ { - clientID: &[]byte{0, 1}, - Flags: 0x00, - IsReply: 0x00, - Type: []byte{0, 0x6a}, - ID: []byte{0x9a, 0xcb, 0x04, 0x42}, - ErrorCode: []byte{0, 0, 0, 0}, + clientID: [2]byte{0, 1}, + Type: [2]byte{0, 0x6a}, Fields: []Field{ NewField(FieldData, []byte("\r Testy McTest: hello")), }, }, { - clientID: &[]byte{0, 2}, - Flags: 0x00, - IsReply: 0x00, - Type: []byte{0, 0x6a}, - ID: []byte{0xf0, 0xc5, 0x34, 0x1e}, - ErrorCode: []byte{0, 0, 0, 0}, + clientID: [2]byte{0, 2}, + Type: [2]byte{0, 0x6a}, Fields: []Field{ NewField(FieldData, []byte("\r Testy McTest: hello")), }, }, }, - wantErr: false, }, { - name: "only sends chat msg to clients with accessReadChat permission", + name: "only sends chat msg to clients with AccessReadChat permission", args: args{ cc: &ClientConn{ Account: &Account{ Access: func() accessBitmap { var bits accessBitmap - bits.Set(accessSendChat) + bits.Set(AccessSendChat) return bits }(), }, UserName: []byte{0x00, 0x01}, Server: &Server{ - Clients: map[uint16]*ClientConn{ - uint16(1): { - Account: &Account{ - Access: func() accessBitmap { - var bits accessBitmap - bits.Set(accessReadChat) - return bits - }()}, - ID: &[]byte{0, 1}, - }, - uint16(2): { - Account: &Account{ - Access: accessBitmap{0, 0, 0, 0, 0, 0, 0, 0}, + ClientMgr: func() *MockClientMgr { + m := MockClientMgr{} + m.On("List").Return([]*ClientConn{ + { + Account: &Account{ + Access: func() accessBitmap { + var bits accessBitmap + bits.Set(AccessReadChat) + return bits + }(), + }, + ID: [2]byte{0, 1}, + }, + { + Account: &Account{}, + ID: [2]byte{0, 2}, }, - ID: &[]byte{0, 2}, }, - }, + ) + return &m + }(), }, }, - t: &Transaction{ + t: Transaction{ Fields: []Field{ NewField(FieldData, []byte("hai")), }, @@ -613,18 +589,13 @@ func TestHandleChatSend(t *testing.T) { }, want: []Transaction{ { - clientID: &[]byte{0, 1}, - Flags: 0x00, - IsReply: 0x00, - Type: []byte{0, 0x6a}, - ID: []byte{0x9a, 0xcb, 0x04, 0x42}, // Random ID from rand.Seed(1) - ErrorCode: []byte{0, 0, 0, 0}, + clientID: [2]byte{0, 1}, + Type: [2]byte{0, 0x6a}, Fields: []Field{ NewField(FieldData, []byte{0x0d, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x01, 0x3a, 0x20, 0x20, 0x68, 0x61, 0x69}), }, }, }, - wantErr: false, }, { name: "only sends private chat msg to members of private chat", @@ -633,47 +604,53 @@ func TestHandleChatSend(t *testing.T) { Account: &Account{ Access: func() accessBitmap { var bits accessBitmap - bits.Set(accessSendChat) + bits.Set(AccessSendChat) return bits }(), }, UserName: []byte{0x00, 0x01}, Server: &Server{ - PrivateChats: map[uint32]*PrivateChat{ - uint32(1): { - ClientConn: map[uint16]*ClientConn{ - uint16(1): { - ID: &[]byte{0, 1}, - }, - uint16(2): { - ID: &[]byte{0, 2}, - }, + ChatMgr: func() *MockChatManager { + m := MockChatManager{} + m.On("Members", ChatID{0x0, 0x0, 0x0, 0x1}).Return([]*ClientConn{ + { + ID: [2]byte{0, 1}, }, - }, - }, - Clients: map[uint16]*ClientConn{ - uint16(1): { - Account: &Account{ - Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255}, + { + ID: [2]byte{0, 2}, }, - ID: &[]byte{0, 1}, - }, - uint16(2): { - Account: &Account{ - Access: accessBitmap{0, 0, 0, 0, 0, 0, 0, 0}, + }) + m.On("GetSubject").Return("unset") + return &m + }(), + ClientMgr: func() *MockClientMgr { + m := MockClientMgr{} + m.On("List").Return([]*ClientConn{ + { + Account: &Account{ + Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255}, + }, + ID: [2]byte{0, 1}, }, - ID: &[]byte{0, 2}, - }, - uint16(3): { - Account: &Account{ - Access: accessBitmap{0, 0, 0, 0, 0, 0, 0, 0}, + { + Account: &Account{ + Access: accessBitmap{0, 0, 0, 0, 0, 0, 0, 0}, + }, + ID: [2]byte{0, 2}, + }, + { + Account: &Account{ + Access: accessBitmap{0, 0, 0, 0, 0, 0, 0, 0}, + }, + ID: [2]byte{0, 3}, }, - ID: &[]byte{0, 3}, }, - }, + ) + return &m + }(), }, }, - t: &Transaction{ + t: Transaction{ Fields: []Field{ NewField(FieldData, []byte("hai")), NewField(FieldChatID, []byte{0, 0, 0, 1}), @@ -682,67 +659,50 @@ func TestHandleChatSend(t *testing.T) { }, want: []Transaction{ { - clientID: &[]byte{0, 1}, - Flags: 0x00, - IsReply: 0x00, - Type: []byte{0, 0x6a}, - ID: []byte{0x9a, 0xcb, 0x04, 0x42}, - ErrorCode: []byte{0, 0, 0, 0}, + clientID: [2]byte{0, 1}, + Type: [2]byte{0, 0x6a}, Fields: []Field{ NewField(FieldChatID, []byte{0, 0, 0, 1}), NewField(FieldData, []byte{0x0d, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x01, 0x3a, 0x20, 0x20, 0x68, 0x61, 0x69}), }, }, { - clientID: &[]byte{0, 2}, - Flags: 0x00, - IsReply: 0x00, - Type: []byte{0, 0x6a}, - ID: []byte{0x9a, 0xcb, 0x04, 0x42}, - ErrorCode: []byte{0, 0, 0, 0}, + clientID: [2]byte{0, 2}, + Type: [2]byte{0, 0x6a}, Fields: []Field{ NewField(FieldChatID, []byte{0, 0, 0, 1}), NewField(FieldData, []byte{0x0d, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x01, 0x3a, 0x20, 0x20, 0x68, 0x61, 0x69}), }, }, }, - wantErr: false, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - got, err := HandleChatSend(tt.args.cc, tt.args.t) - - if (err != nil) != tt.wantErr { - t.Errorf("HandleChatSend() error = %v, wantErr %v", err, tt.wantErr) - return - } + got := HandleChatSend(tt.args.cc, &tt.args.t) tranAssertEqual(t, tt.want, got) }) } } func TestHandleGetFileInfo(t *testing.T) { - rand.Seed(1) // reset seed between tests to make transaction IDs predictable - type args struct { cc *ClientConn - t *Transaction + t Transaction } tests := []struct { name string args args wantRes []Transaction - wantErr bool }{ { name: "returns expected fields when a valid file is requested", args: args{ cc: &ClientConn{ - ID: &[]byte{0x00, 0x01}, + ID: [2]byte{0x00, 0x01}, Server: &Server{ FS: &OSFileStore{}, - Config: &Config{ + Config: Config{ FileRoot: func() string { path, _ := os.Getwd() return filepath.Join(path, "/test/config/Files") @@ -751,19 +711,16 @@ func TestHandleGetFileInfo(t *testing.T) { }, }, t: NewTransaction( - TranGetFileInfo, nil, + TranGetFileInfo, [2]byte{}, NewField(FieldFileName, []byte("testfile.txt")), NewField(FieldFilePath, []byte{0x00, 0x00}), ), }, wantRes: []Transaction{ { - clientID: &[]byte{0, 1}, - Flags: 0x00, - IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0x9a, 0xcb, 0x04, 0x42}, // Random ID from rand.Seed(1) - ErrorCode: []byte{0, 0, 0, 0}, + clientID: [2]byte{0, 1}, + IsReply: 0x01, + Type: [2]byte{0, 0}, Fields: []Field{ NewField(FieldFileName, []byte("testfile.txt")), NewField(FieldFileTypeString, []byte("Text File")), @@ -775,24 +732,18 @@ func TestHandleGetFileInfo(t *testing.T) { }, }, }, - wantErr: false, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - rand.Seed(1) // reset seed between tests to make transaction IDs predictable - - gotRes, err := HandleGetFileInfo(tt.args.cc, tt.args.t) - if (err != nil) != tt.wantErr { - t.Errorf("HandleGetFileInfo() error = %v, wantErr %v", err, tt.wantErr) - return - } + gotRes := HandleGetFileInfo(tt.args.cc, &tt.args.t) - // Clear the fileWrapper timestamp fields to work around problems running the tests in multiple timezones + // Clear the file timestamp fields to work around problems running the tests in multiple timezones // TODO: revisit how to test this by mocking the stat calls gotRes[0].Fields[4].Data = make([]byte, 8) gotRes[0].Fields[5].Data = make([]byte, 8) - if !assert.Equal(t, tt.wantRes, gotRes) { + + if !tranAssertEqual(t, tt.wantRes, gotRes) { t.Errorf("HandleGetFileInfo() gotRes = %v, want %v", gotRes, tt.wantRes) } }) @@ -802,13 +753,12 @@ func TestHandleGetFileInfo(t *testing.T) { func TestHandleNewFolder(t *testing.T) { type args struct { cc *ClientConn - t *Transaction + t Transaction } tests := []struct { name string args args wantRes []Transaction - wantErr bool }{ { name: "without required permission", @@ -822,23 +772,19 @@ func TestHandleNewFolder(t *testing.T) { }, }, t: NewTransaction( - accessCreateFolder, - &[]byte{0, 0}, + TranNewFolder, + [2]byte{0, 0}, ), }, wantRes: []Transaction{ { - Flags: 0x00, IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0x9a, 0xcb, 0x04, 0x42}, - ErrorCode: []byte{0, 0, 0, 1}, + ErrorCode: [4]byte{0, 0, 0, 1}, Fields: []Field{ NewField(FieldError, []byte("You are not allowed to create folders.")), }, }, }, - wantErr: false, }, { name: "when path is nested", @@ -847,13 +793,13 @@ func TestHandleNewFolder(t *testing.T) { Account: &Account{ Access: func() accessBitmap { var bits accessBitmap - bits.Set(accessCreateFolder) + bits.Set(AccessCreateFolder) return bits }(), }, - ID: &[]byte{0, 1}, + ID: [2]byte{0, 1}, Server: &Server{ - Config: &Config{ + Config: Config{ FileRoot: "/Files/", }, FS: func() *MockFileStore { @@ -865,7 +811,7 @@ func TestHandleNewFolder(t *testing.T) { }, }, t: NewTransaction( - TranNewFolder, &[]byte{0, 1}, + TranNewFolder, [2]byte{0, 1}, NewField(FieldFileName, []byte("testFolder")), NewField(FieldFilePath, []byte{ 0x00, 0x01, @@ -877,15 +823,10 @@ func TestHandleNewFolder(t *testing.T) { }, wantRes: []Transaction{ { - clientID: &[]byte{0, 1}, - Flags: 0x00, - IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0x9a, 0xcb, 0x04, 0x42}, // Random ID from rand.Seed(1) - ErrorCode: []byte{0, 0, 0, 0}, + clientID: [2]byte{0, 1}, + IsReply: 0x01, }, }, - wantErr: false, }, { name: "when path is not nested", @@ -894,13 +835,13 @@ func TestHandleNewFolder(t *testing.T) { Account: &Account{ Access: func() accessBitmap { var bits accessBitmap - bits.Set(accessCreateFolder) + bits.Set(AccessCreateFolder) return bits }(), }, - ID: &[]byte{0, 1}, + ID: [2]byte{0, 1}, Server: &Server{ - Config: &Config{ + Config: Config{ FileRoot: "/Files", }, FS: func() *MockFileStore { @@ -912,21 +853,16 @@ func TestHandleNewFolder(t *testing.T) { }, }, t: NewTransaction( - TranNewFolder, &[]byte{0, 1}, + TranNewFolder, [2]byte{0, 1}, NewField(FieldFileName, []byte("testFolder")), ), }, wantRes: []Transaction{ { - clientID: &[]byte{0, 1}, - Flags: 0x00, - IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0x9a, 0xcb, 0x04, 0x42}, // Random ID from rand.Seed(1) - ErrorCode: []byte{0, 0, 0, 0}, + clientID: [2]byte{0, 1}, + IsReply: 0x01, }, }, - wantErr: false, }, { name: "when Write returns an err", @@ -935,13 +871,13 @@ func TestHandleNewFolder(t *testing.T) { Account: &Account{ Access: func() accessBitmap { var bits accessBitmap - bits.Set(accessCreateFolder) + bits.Set(AccessCreateFolder) return bits }(), }, - ID: &[]byte{0, 1}, + ID: [2]byte{0, 1}, Server: &Server{ - Config: &Config{ + Config: Config{ FileRoot: "/Files/", }, FS: func() *MockFileStore { @@ -953,7 +889,7 @@ func TestHandleNewFolder(t *testing.T) { }, }, t: NewTransaction( - TranNewFolder, &[]byte{0, 1}, + TranNewFolder, [2]byte{0, 1}, NewField(FieldFileName, []byte("testFolder")), NewField(FieldFilePath, []byte{ 0x00, @@ -961,7 +897,6 @@ func TestHandleNewFolder(t *testing.T) { ), }, wantRes: []Transaction{}, - wantErr: true, }, { name: "FieldFileName does not allow directory traversal", @@ -970,13 +905,13 @@ func TestHandleNewFolder(t *testing.T) { Account: &Account{ Access: func() accessBitmap { var bits accessBitmap - bits.Set(accessCreateFolder) + bits.Set(AccessCreateFolder) return bits }(), }, - ID: &[]byte{0, 1}, + ID: [2]byte{0, 1}, Server: &Server{ - Config: &Config{ + Config: Config{ FileRoot: "/Files/", }, FS: func() *MockFileStore { @@ -988,20 +923,16 @@ func TestHandleNewFolder(t *testing.T) { }, }, t: NewTransaction( - TranNewFolder, &[]byte{0, 1}, + TranNewFolder, [2]byte{0, 1}, NewField(FieldFileName, []byte("../../testFolder")), ), }, wantRes: []Transaction{ { - clientID: &[]byte{0, 1}, - Flags: 0x00, - IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0x9a, 0xcb, 0x04, 0x42}, // Random ID from rand.Seed(1) - ErrorCode: []byte{0, 0, 0, 0}, + clientID: [2]byte{0, 1}, + IsReply: 0x01, }, - }, wantErr: false, + }, }, { name: "FieldFilePath does not allow directory traversal", @@ -1010,13 +941,13 @@ func TestHandleNewFolder(t *testing.T) { Account: &Account{ Access: func() accessBitmap { var bits accessBitmap - bits.Set(accessCreateFolder) + bits.Set(AccessCreateFolder) return bits }(), }, - ID: &[]byte{0, 1}, + ID: [2]byte{0, 1}, Server: &Server{ - Config: &Config{ + Config: Config{ FileRoot: "/Files/", }, FS: func() *MockFileStore { @@ -1028,7 +959,7 @@ func TestHandleNewFolder(t *testing.T) { }, }, t: NewTransaction( - TranNewFolder, &[]byte{0, 1}, + TranNewFolder, [2]byte{0, 1}, NewField(FieldFileName, []byte("testFolder")), NewField(FieldFilePath, []byte{ 0x00, 0x02, @@ -1043,23 +974,15 @@ func TestHandleNewFolder(t *testing.T) { }, wantRes: []Transaction{ { - clientID: &[]byte{0, 1}, - Flags: 0x00, - IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0x9a, 0xcb, 0x04, 0x42}, // Random ID from rand.Seed(1) - ErrorCode: []byte{0, 0, 0, 0}, + clientID: [2]byte{0, 1}, + IsReply: 0x01, }, - }, wantErr: false, + }, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - gotRes, err := HandleNewFolder(tt.args.cc, tt.args.t) - if (err != nil) != tt.wantErr { - t.Errorf("HandleNewFolder() error = %v, wantErr %v", err, tt.wantErr) - return - } + gotRes := HandleNewFolder(tt.args.cc, &tt.args.t) if !tranAssertEqual(t, tt.wantRes, gotRes) { t.Errorf("HandleNewFolder() gotRes = %v, want %v", gotRes, tt.wantRes) @@ -1071,38 +994,35 @@ func TestHandleNewFolder(t *testing.T) { func TestHandleUploadFile(t *testing.T) { type args struct { cc *ClientConn - t *Transaction + t Transaction } tests := []struct { name string args args wantRes []Transaction - wantErr bool }{ { name: "when request is valid and user has Upload Anywhere permission", args: args{ cc: &ClientConn{ Server: &Server{ - FS: &OSFileStore{}, - fileTransfers: map[[4]byte]*FileTransfer{}, - Config: &Config{ + FS: &OSFileStore{}, + FileTransferMgr: NewMemFileTransferMgr(), + Config: Config{ FileRoot: func() string { path, _ := os.Getwd(); return path + "/test/config/Files" }(), }}, - transfers: map[int]map[[4]byte]*FileTransfer{ - FileUpload: {}, - }, + ClientFileTransferMgr: NewClientFileTransferMgr(), Account: &Account{ Access: func() accessBitmap { var bits accessBitmap - bits.Set(accessUploadFile) - bits.Set(accessUploadAnywhere) + bits.Set(AccessUploadFile) + bits.Set(AccessUploadAnywhere) return bits }(), }, }, t: NewTransaction( - TranUploadFile, &[]byte{0, 1}, + TranUploadFile, [2]byte{0, 1}, NewField(FieldFileName, []byte("testFile")), NewField(FieldFilePath, []byte{ 0x00, 0x01, @@ -1114,17 +1034,12 @@ func TestHandleUploadFile(t *testing.T) { }, wantRes: []Transaction{ { - Flags: 0x00, - IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0x9a, 0xcb, 0x04, 0x42}, - ErrorCode: []byte{0, 0, 0, 0}, + IsReply: 0x01, Fields: []Field{ NewField(FieldRefNum, []byte{0x52, 0xfd, 0xfc, 0x07}), // rand.Seed(1) }, }, }, - wantErr: false, }, { name: "when user does not have required access", @@ -1138,7 +1053,7 @@ func TestHandleUploadFile(t *testing.T) { }, }, t: NewTransaction( - TranUploadFile, &[]byte{0, 1}, + TranUploadFile, [2]byte{0, 1}, NewField(FieldFileName, []byte("testFile")), NewField(FieldFilePath, []byte{ 0x00, 0x01, @@ -1150,28 +1065,18 @@ func TestHandleUploadFile(t *testing.T) { }, wantRes: []Transaction{ { - Flags: 0x00, IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0x9a, 0xcb, 0x04, 0x42}, - ErrorCode: []byte{0, 0, 0, 1}, + ErrorCode: [4]byte{0, 0, 0, 1}, Fields: []Field{ NewField(FieldError, []byte("You are not allowed to upload files.")), // rand.Seed(1) }, }, }, - wantErr: false, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - rand.Seed(1) - gotRes, err := HandleUploadFile(tt.args.cc, tt.args.t) - if (err != nil) != tt.wantErr { - t.Errorf("HandleUploadFile() error = %v, wantErr %v", err, tt.wantErr) - return - } - + gotRes := HandleUploadFile(tt.args.cc, &tt.args.t) tranAssertEqual(t, tt.wantRes, gotRes) }) } @@ -1180,13 +1085,12 @@ func TestHandleUploadFile(t *testing.T) { func TestHandleMakeAlias(t *testing.T) { type args struct { cc *ClientConn - t *Transaction + t Transaction } tests := []struct { name string args args wantRes []Transaction - wantErr bool }{ { name: "with valid input and required permissions", @@ -1196,12 +1100,12 @@ func TestHandleMakeAlias(t *testing.T) { Account: &Account{ Access: func() accessBitmap { var bits accessBitmap - bits.Set(accessMakeAlias) + bits.Set(AccessMakeAlias) return bits }(), }, Server: &Server{ - Config: &Config{ + Config: Config{ FileRoot: func() string { path, _ := os.Getwd() return path + "/test/config/Files" @@ -1221,7 +1125,7 @@ func TestHandleMakeAlias(t *testing.T) { }, }, t: NewTransaction( - TranMakeFileAlias, &[]byte{0, 1}, + TranMakeFileAlias, [2]byte{0, 1}, NewField(FieldFileName, []byte("testFile")), NewField(FieldFilePath, EncodeFilePath(strings.Join([]string{"foo"}, "/"))), NewField(FieldFileNewPath, EncodeFilePath(strings.Join([]string{"bar"}, "/"))), @@ -1229,15 +1133,10 @@ func TestHandleMakeAlias(t *testing.T) { }, wantRes: []Transaction{ { - Flags: 0x00, - IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0x9a, 0xcb, 0x04, 0x42}, - ErrorCode: []byte{0, 0, 0, 0}, - Fields: []Field(nil), + IsReply: 0x01, + Fields: []Field(nil), }, }, - wantErr: false, }, { name: "when symlink returns an error", @@ -1247,12 +1146,12 @@ func TestHandleMakeAlias(t *testing.T) { Account: &Account{ Access: func() accessBitmap { var bits accessBitmap - bits.Set(accessMakeAlias) + bits.Set(AccessMakeAlias) return bits }(), }, Server: &Server{ - Config: &Config{ + Config: Config{ FileRoot: func() string { path, _ := os.Getwd() return path + "/test/config/Files" @@ -1272,7 +1171,7 @@ func TestHandleMakeAlias(t *testing.T) { }, }, t: NewTransaction( - TranMakeFileAlias, &[]byte{0, 1}, + TranMakeFileAlias, [2]byte{0, 1}, NewField(FieldFileName, []byte("testFile")), NewField(FieldFilePath, EncodeFilePath(strings.Join([]string{"foo"}, "/"))), NewField(FieldFileNewPath, EncodeFilePath(strings.Join([]string{"bar"}, "/"))), @@ -1280,17 +1179,13 @@ func TestHandleMakeAlias(t *testing.T) { }, wantRes: []Transaction{ { - Flags: 0x00, IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0x9a, 0xcb, 0x04, 0x42}, - ErrorCode: []byte{0, 0, 0, 1}, + ErrorCode: [4]byte{0, 0, 0, 1}, Fields: []Field{ NewField(FieldError, []byte("Error creating alias")), }, }, }, - wantErr: false, }, { name: "when user does not have required permission", @@ -1298,13 +1193,10 @@ func TestHandleMakeAlias(t *testing.T) { cc: &ClientConn{ logger: NewTestLogger(), Account: &Account{ - Access: func() accessBitmap { - var bits accessBitmap - return bits - }(), + Access: accessBitmap{}, }, Server: &Server{ - Config: &Config{ + Config: Config{ FileRoot: func() string { path, _ := os.Getwd() return path + "/test/config/Files" @@ -1313,7 +1205,7 @@ func TestHandleMakeAlias(t *testing.T) { }, }, t: NewTransaction( - TranMakeFileAlias, &[]byte{0, 1}, + TranMakeFileAlias, [2]byte{0, 1}, NewField(FieldFileName, []byte("testFile")), NewField(FieldFilePath, []byte{ 0x00, 0x01, @@ -1331,27 +1223,18 @@ func TestHandleMakeAlias(t *testing.T) { }, wantRes: []Transaction{ { - Flags: 0x00, IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0x9a, 0xcb, 0x04, 0x42}, - ErrorCode: []byte{0, 0, 0, 1}, + ErrorCode: [4]byte{0, 0, 0, 1}, Fields: []Field{ NewField(FieldError, []byte("You are not allowed to make aliases.")), }, }, }, - wantErr: false, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - gotRes, err := HandleMakeAlias(tt.args.cc, tt.args.t) - if (err != nil) != tt.wantErr { - t.Errorf("HandleMakeAlias(%v, %v)", tt.args.cc, tt.args.t) - return - } - + gotRes := HandleMakeAlias(tt.args.cc, &tt.args.t) tranAssertEqual(t, tt.wantRes, gotRes) }) } @@ -1360,13 +1243,12 @@ func TestHandleMakeAlias(t *testing.T) { func TestHandleGetUser(t *testing.T) { type args struct { cc *ClientConn - t *Transaction + t Transaction } tests := []struct { name string args args wantRes []Transaction - wantErr assert.ErrorAssertionFunc }{ { name: "when account is valid", @@ -1375,33 +1257,31 @@ func TestHandleGetUser(t *testing.T) { Account: &Account{ Access: func() accessBitmap { var bits accessBitmap - bits.Set(accessOpenUser) + bits.Set(AccessOpenUser) return bits }(), }, Server: &Server{ - Accounts: map[string]*Account{ - "guest": { + AccountManager: func() *MockAccountManager { + m := MockAccountManager{} + m.On("Get", "guest").Return(&Account{ Login: "guest", Name: "Guest", Password: "password", Access: accessBitmap{}, - }, - }, + }) + return &m + }(), }, }, t: NewTransaction( - TranGetUser, &[]byte{0, 1}, + TranGetUser, [2]byte{0, 1}, NewField(FieldUserLogin, []byte("guest")), ), }, wantRes: []Transaction{ { - Flags: 0x00, - IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0x9a, 0xcb, 0x04, 0x42}, - ErrorCode: []byte{0, 0, 0, 0}, + IsReply: 0x01, Fields: []Field{ NewField(FieldUserName, []byte("Guest")), NewField(FieldUserLogin, encodeString([]byte("guest"))), @@ -1410,7 +1290,6 @@ func TestHandleGetUser(t *testing.T) { }, }, }, - wantErr: assert.NoError, }, { name: "when user does not have required permission", @@ -1423,27 +1302,23 @@ func TestHandleGetUser(t *testing.T) { }(), }, Server: &Server{ - Accounts: map[string]*Account{}, + //Accounts: map[string]*Account{}, }, }, t: NewTransaction( - TranGetUser, &[]byte{0, 1}, + TranGetUser, [2]byte{0, 1}, NewField(FieldUserLogin, []byte("nonExistentUser")), ), }, wantRes: []Transaction{ { - Flags: 0x00, IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0x9a, 0xcb, 0x04, 0x42}, - ErrorCode: []byte{0, 0, 0, 1}, + ErrorCode: [4]byte{0, 0, 0, 1}, Fields: []Field{ NewField(FieldError, []byte("You are not allowed to view accounts.")), }, }, }, - wantErr: assert.NoError, }, { name: "when account does not exist", @@ -1452,16 +1327,20 @@ func TestHandleGetUser(t *testing.T) { Account: &Account{ Access: func() accessBitmap { var bits accessBitmap - bits.Set(accessOpenUser) + bits.Set(AccessOpenUser) return bits }(), }, Server: &Server{ - Accounts: map[string]*Account{}, + AccountManager: func() *MockAccountManager { + m := MockAccountManager{} + m.On("Get", "nonExistentUser").Return((*Account)(nil)) + return &m + }(), }, }, t: NewTransaction( - TranGetUser, &[]byte{0, 1}, + TranGetUser, [2]byte{0, 1}, NewField(FieldUserLogin, []byte("nonExistentUser")), ), }, @@ -1469,24 +1348,18 @@ func TestHandleGetUser(t *testing.T) { { Flags: 0x00, IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0x9a, 0xcb, 0x04, 0x42}, - ErrorCode: []byte{0, 0, 0, 1}, + Type: [2]byte{0, 0}, + ErrorCode: [4]byte{0, 0, 0, 1}, Fields: []Field{ NewField(FieldError, []byte("Account does not exist.")), }, }, }, - wantErr: assert.NoError, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - gotRes, err := HandleGetUser(tt.args.cc, tt.args.t) - if !tt.wantErr(t, err, fmt.Sprintf("HandleGetUser(%v, %v)", tt.args.cc, tt.args.t)) { - return - } - + gotRes := HandleGetUser(tt.args.cc, &tt.args.t) tranAssertEqual(t, tt.wantRes, gotRes) }) } @@ -1495,99 +1368,81 @@ func TestHandleGetUser(t *testing.T) { func TestHandleDeleteUser(t *testing.T) { type args struct { cc *ClientConn - t *Transaction + t Transaction } tests := []struct { name string args args wantRes []Transaction - wantErr assert.ErrorAssertionFunc }{ { - name: "when user dataFile", + name: "when user exists", args: args{ cc: &ClientConn{ Account: &Account{ Access: func() accessBitmap { var bits accessBitmap - bits.Set(accessDeleteUser) + bits.Set(AccessDeleteUser) return bits }(), }, Server: &Server{ - Accounts: map[string]*Account{ - "testuser": { - Login: "testuser", - Name: "Testy McTest", - Password: "password", - Access: accessBitmap{}, - }, - }, - FS: func() *MockFileStore { - mfs := &MockFileStore{} - mfs.On("Remove", "Users/testuser.yaml").Return(nil) - return mfs + AccountManager: func() *MockAccountManager { + m := MockAccountManager{} + m.On("Delete", "testuser").Return(nil) + return &m + }(), + ClientMgr: func() *MockClientMgr { + m := MockClientMgr{} + m.On("List").Return([]*ClientConn{}) // TODO + return &m }(), }, }, t: NewTransaction( - TranDeleteUser, &[]byte{0, 1}, + TranDeleteUser, [2]byte{0, 1}, NewField(FieldUserLogin, encodeString([]byte("testuser"))), ), }, wantRes: []Transaction{ { - Flags: 0x00, - IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0x9a, 0xcb, 0x04, 0x42}, - ErrorCode: []byte{0, 0, 0, 0}, - Fields: []Field(nil), + Flags: 0x00, + IsReply: 0x01, + Type: [2]byte{0, 0}, + Fields: []Field(nil), }, }, - wantErr: assert.NoError, }, { name: "when user does not have required permission", args: args{ cc: &ClientConn{ Account: &Account{ - Access: func() accessBitmap { - var bits accessBitmap - return bits - }(), + Access: accessBitmap{}, }, Server: &Server{ - Accounts: map[string]*Account{}, + //Accounts: map[string]*Account{}, }, }, t: NewTransaction( - TranDeleteUser, &[]byte{0, 1}, + TranDeleteUser, [2]byte{0, 1}, NewField(FieldUserLogin, encodeString([]byte("testuser"))), ), }, wantRes: []Transaction{ { - Flags: 0x00, IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0x9a, 0xcb, 0x04, 0x42}, - ErrorCode: []byte{0, 0, 0, 1}, + ErrorCode: [4]byte{0, 0, 0, 1}, Fields: []Field{ NewField(FieldError, []byte("You are not allowed to delete accounts.")), }, }, }, - wantErr: assert.NoError, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - gotRes, err := HandleDeleteUser(tt.args.cc, tt.args.t) - if !tt.wantErr(t, err, fmt.Sprintf("HandleDeleteUser(%v, %v)", tt.args.cc, tt.args.t)) { - return - } - + gotRes := HandleDeleteUser(tt.args.cc, &tt.args.t) tranAssertEqual(t, tt.wantRes, gotRes) }) } @@ -1596,13 +1451,12 @@ func TestHandleDeleteUser(t *testing.T) { func TestHandleGetMsgs(t *testing.T) { type args struct { cc *ClientConn - t *Transaction + t Transaction } tests := []struct { name string args args wantRes []Transaction - wantErr assert.ErrorAssertionFunc }{ { name: "returns news data", @@ -1611,72 +1465,64 @@ func TestHandleGetMsgs(t *testing.T) { Account: &Account{ Access: func() accessBitmap { var bits accessBitmap - bits.Set(accessNewsReadArt) + bits.Set(AccessNewsReadArt) return bits }(), }, Server: &Server{ - FlatNews: []byte("TEST"), + MessageBoard: func() *mockReadWriteSeeker { + m := mockReadWriteSeeker{} + m.On("Seek", int64(0), 0).Return(int64(0), nil) + m.On("Read", mock.AnythingOfType("[]uint8")).Run(func(args mock.Arguments) { + arg := args.Get(0).([]uint8) + copy(arg, "TEST") + }).Return(4, io.EOF) + return &m + }(), }, }, t: NewTransaction( - TranGetMsgs, &[]byte{0, 1}, + TranGetMsgs, [2]byte{0, 1}, ), }, wantRes: []Transaction{ { - Flags: 0x00, - IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0x9a, 0xcb, 0x04, 0x42}, - ErrorCode: []byte{0, 0, 0, 0}, + IsReply: 0x01, Fields: []Field{ NewField(FieldData, []byte("TEST")), }, }, }, - wantErr: assert.NoError, }, { name: "when user does not have required permission", args: args{ cc: &ClientConn{ Account: &Account{ - Access: func() accessBitmap { - var bits accessBitmap - return bits - }(), + Access: accessBitmap{}, }, Server: &Server{ - Accounts: map[string]*Account{}, + //Accounts: map[string]*Account{}, }, }, t: NewTransaction( - TranGetMsgs, &[]byte{0, 1}, + TranGetMsgs, [2]byte{0, 1}, ), }, wantRes: []Transaction{ { - Flags: 0x00, IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0x9a, 0xcb, 0x04, 0x42}, - ErrorCode: []byte{0, 0, 0, 1}, + ErrorCode: [4]byte{0, 0, 0, 1}, Fields: []Field{ NewField(FieldError, []byte("You are not allowed to read news.")), }, }, }, - wantErr: assert.NoError, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - gotRes, err := HandleGetMsgs(tt.args.cc, tt.args.t) - if !tt.wantErr(t, err, fmt.Sprintf("HandleGetMsgs(%v, %v)", tt.args.cc, tt.args.t)) { - return - } - + gotRes := HandleGetMsgs(tt.args.cc, &tt.args.t) tranAssertEqual(t, tt.wantRes, gotRes) }) } @@ -1685,13 +1531,12 @@ func TestHandleGetMsgs(t *testing.T) { func TestHandleNewUser(t *testing.T) { type args struct { cc *ClientConn - t *Transaction + t Transaction } tests := []struct { name string args args wantRes []Transaction - wantErr assert.ErrorAssertionFunc }{ { name: "when user does not have required permission", @@ -1704,26 +1549,22 @@ func TestHandleNewUser(t *testing.T) { }(), }, Server: &Server{ - Accounts: map[string]*Account{}, + //Accounts: map[string]*Account{}, }, }, t: NewTransaction( - TranNewUser, &[]byte{0, 1}, + TranNewUser, [2]byte{0, 1}, ), }, wantRes: []Transaction{ { - Flags: 0x00, IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0x9a, 0xcb, 0x04, 0x42}, - ErrorCode: []byte{0, 0, 0, 1}, + ErrorCode: [4]byte{0, 0, 0, 1}, Fields: []Field{ NewField(FieldError, []byte("You are not allowed to create new accounts.")), }, }, }, - wantErr: assert.NoError, }, { name: "when user attempts to create account with greater access", @@ -1732,22 +1573,26 @@ func TestHandleNewUser(t *testing.T) { Account: &Account{ Access: func() accessBitmap { var bits accessBitmap - bits.Set(accessCreateUser) + bits.Set(AccessCreateUser) return bits }(), }, Server: &Server{ - Accounts: map[string]*Account{}, + AccountManager: func() *MockAccountManager { + m := MockAccountManager{} + m.On("Get", "userB").Return((*Account)(nil)) + return &m + }(), }, }, t: NewTransaction( - TranNewUser, &[]byte{0, 1}, - NewField(FieldUserLogin, []byte("userB")), + TranNewUser, [2]byte{0, 1}, + NewField(FieldUserLogin, encodeString([]byte("userB"))), NewField( FieldUserAccess, func() []byte { var bits accessBitmap - bits.Set(accessDisconUser) + bits.Set(AccessDisconUser) return bits[:] }(), ), @@ -1755,26 +1600,18 @@ func TestHandleNewUser(t *testing.T) { }, wantRes: []Transaction{ { - Flags: 0x00, IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0x9a, 0xcb, 0x04, 0x42}, - ErrorCode: []byte{0, 0, 0, 1}, + ErrorCode: [4]byte{0, 0, 0, 1}, Fields: []Field{ NewField(FieldError, []byte("Cannot create account with more access than yourself.")), }, }, }, - wantErr: assert.NoError, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - gotRes, err := HandleNewUser(tt.args.cc, tt.args.t) - if !tt.wantErr(t, err, fmt.Sprintf("HandleNewUser(%v, %v)", tt.args.cc, tt.args.t)) { - return - } - + gotRes := HandleNewUser(tt.args.cc, &tt.args.t) tranAssertEqual(t, tt.wantRes, gotRes) }) } @@ -1783,13 +1620,12 @@ func TestHandleNewUser(t *testing.T) { func TestHandleListUsers(t *testing.T) { type args struct { cc *ClientConn - t *Transaction + t Transaction } tests := []struct { name string args args wantRes []Transaction - wantErr assert.ErrorAssertionFunc }{ { name: "when user does not have required permission", @@ -1802,26 +1638,22 @@ func TestHandleListUsers(t *testing.T) { }(), }, Server: &Server{ - Accounts: map[string]*Account{}, + //Accounts: map[string]*Account{}, }, }, t: NewTransaction( - TranNewUser, &[]byte{0, 1}, + TranNewUser, [2]byte{0, 1}, ), }, wantRes: []Transaction{ { - Flags: 0x00, IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0x9a, 0xcb, 0x04, 0x42}, - ErrorCode: []byte{0, 0, 0, 1}, + ErrorCode: [4]byte{0, 0, 0, 1}, Fields: []Field{ NewField(FieldError, []byte("You are not allowed to view accounts.")), }, }, }, - wantErr: assert.NoError, }, { name: "when user has required permission", @@ -1830,33 +1662,33 @@ func TestHandleListUsers(t *testing.T) { Account: &Account{ Access: func() accessBitmap { var bits accessBitmap - bits.Set(accessOpenUser) + bits.Set(AccessOpenUser) return bits }(), }, Server: &Server{ - Accounts: map[string]*Account{ - "guest": { - Name: "guest", - Login: "guest", - Password: "zz", - Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255}, - }, - }, + AccountManager: func() *MockAccountManager { + m := MockAccountManager{} + m.On("List").Return([]Account{ + { + Name: "guest", + Login: "guest", + Password: "zz", + Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255}, + }, + }) + return &m + }(), }, }, t: NewTransaction( - TranGetClientInfoText, &[]byte{0, 1}, + TranGetClientInfoText, [2]byte{0, 1}, NewField(FieldUserID, []byte{0, 1}), ), }, wantRes: []Transaction{ { - Flags: 0x00, - IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0, 0, 0, 0}, - ErrorCode: []byte{0, 0, 0, 0}, + IsReply: 0x01, Fields: []Field{ NewField(FieldData, []byte{ 0x00, 0x04, 0x00, 0x66, 0x00, 0x05, 0x67, 0x75, 0x65, 0x73, 0x74, 0x00, 0x69, 0x00, 0x05, 0x98, @@ -1866,15 +1698,11 @@ func TestHandleListUsers(t *testing.T) { }, }, }, - wantErr: assert.NoError, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - gotRes, err := HandleListUsers(tt.args.cc, tt.args.t) - if !tt.wantErr(t, err, fmt.Sprintf("HandleListUsers(%v, %v)", tt.args.cc, tt.args.t)) { - return - } + gotRes := HandleListUsers(tt.args.cc, &tt.args.t) tranAssertEqual(t, tt.wantRes, gotRes) }) @@ -1884,13 +1712,12 @@ func TestHandleListUsers(t *testing.T) { func TestHandleDownloadFile(t *testing.T) { type args struct { cc *ClientConn - t *Transaction + t Transaction } tests := []struct { name string args args wantRes []Transaction - wantErr assert.ErrorAssertionFunc }{ { name: "when user does not have required permission", @@ -1904,59 +1731,48 @@ func TestHandleDownloadFile(t *testing.T) { }, Server: &Server{}, }, - t: NewTransaction(TranDownloadFile, &[]byte{0, 1}), + t: NewTransaction(TranDownloadFile, [2]byte{0, 1}), }, wantRes: []Transaction{ { - Flags: 0x00, IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0x9a, 0xcb, 0x04, 0x42}, - ErrorCode: []byte{0, 0, 0, 1}, + ErrorCode: [4]byte{0, 0, 0, 1}, Fields: []Field{ NewField(FieldError, []byte("You are not allowed to download files.")), }, }, }, - wantErr: assert.NoError, }, { name: "with a valid file", args: args{ cc: &ClientConn{ - transfers: map[int]map[[4]byte]*FileTransfer{ - FileDownload: {}, - }, + ClientFileTransferMgr: NewClientFileTransferMgr(), Account: &Account{ Access: func() accessBitmap { var bits accessBitmap - bits.Set(accessDownloadFile) + bits.Set(AccessDownloadFile) return bits }(), }, Server: &Server{ - FS: &OSFileStore{}, - fileTransfers: map[[4]byte]*FileTransfer{}, - Config: &Config{ + FS: &OSFileStore{}, + FileTransferMgr: NewMemFileTransferMgr(), + Config: Config{ FileRoot: func() string { path, _ := os.Getwd(); return path + "/test/config/Files" }(), }, - Accounts: map[string]*Account{}, }, }, t: NewTransaction( - accessDownloadFile, - &[]byte{0, 1}, + TranDownloadFile, + [2]byte{0, 1}, NewField(FieldFileName, []byte("testfile.txt")), NewField(FieldFilePath, []byte{0x0, 0x00}), ), }, wantRes: []Transaction{ { - Flags: 0x00, - IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0x9a, 0xcb, 0x04, 0x42}, - ErrorCode: []byte{0, 0, 0, 0}, + IsReply: 0x01, Fields: []Field{ NewField(FieldRefNum, []byte{0x52, 0xfd, 0xfc, 0x07}), NewField(FieldWaitingCount, []byte{0x00, 0x00}), @@ -1965,18 +1781,16 @@ func TestHandleDownloadFile(t *testing.T) { }, }, }, - wantErr: assert.NoError, }, { name: "when client requests to resume 1k test file at offset 256", args: args{ cc: &ClientConn{ - transfers: map[int]map[[4]byte]*FileTransfer{ - FileDownload: {}, - }, Account: &Account{ + ClientFileTransferMgr: NewClientFileTransferMgr(), + Account: &Account{ Access: func() accessBitmap { var bits accessBitmap - bits.Set(accessDownloadFile) + bits.Set(AccessDownloadFile) return bits }(), }, @@ -2000,38 +1814,31 @@ func TestHandleDownloadFile(t *testing.T) { // // return mfs // }(), - fileTransfers: map[[4]byte]*FileTransfer{}, - Config: &Config{ + FileTransferMgr: NewMemFileTransferMgr(), + Config: Config{ FileRoot: func() string { path, _ := os.Getwd(); return path + "/test/config/Files" }(), }, - Accounts: map[string]*Account{}, + //Accounts: map[string]*Account{}, }, }, t: NewTransaction( - accessDownloadFile, - &[]byte{0, 1}, + TranDownloadFile, + [2]byte{0, 1}, NewField(FieldFileName, []byte("testfile-1k")), NewField(FieldFilePath, []byte{0x00, 0x00}), NewField( FieldFileResumeData, func() []byte { frd := FileResumeData{ - Format: [4]byte{}, - Version: [2]byte{}, - RSVD: [34]byte{}, ForkCount: [2]byte{0, 2}, ForkInfoList: []ForkInfoList{ { Fork: [4]byte{0x44, 0x41, 0x54, 0x41}, // "DATA" DataSize: [4]byte{0, 0, 0x01, 0x00}, // request offset 256 - RSVDA: [4]byte{}, - RSVDB: [4]byte{}, }, { Fork: [4]byte{0x4d, 0x41, 0x43, 0x52}, // "MACR" DataSize: [4]byte{0, 0, 0, 0}, - RSVDA: [4]byte{}, - RSVDB: [4]byte{}, }, }, } @@ -2043,11 +1850,7 @@ func TestHandleDownloadFile(t *testing.T) { }, wantRes: []Transaction{ { - Flags: 0x00, - IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0x9a, 0xcb, 0x04, 0x42}, - ErrorCode: []byte{0, 0, 0, 0}, + IsReply: 0x01, Fields: []Field{ NewField(FieldRefNum, []byte{0x52, 0xfd, 0xfc, 0x07}), NewField(FieldWaitingCount, []byte{0x00, 0x00}), @@ -2056,16 +1859,11 @@ func TestHandleDownloadFile(t *testing.T) { }, }, }, - wantErr: assert.NoError, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - gotRes, err := HandleDownloadFile(tt.args.cc, tt.args.t) - if !tt.wantErr(t, err, fmt.Sprintf("HandleDownloadFile(%v, %v)", tt.args.cc, tt.args.t)) { - return - } - + gotRes := HandleDownloadFile(tt.args.cc, &tt.args.t) tranAssertEqual(t, tt.wantRes, gotRes) }) } @@ -2074,13 +1872,12 @@ func TestHandleDownloadFile(t *testing.T) { func TestHandleUpdateUser(t *testing.T) { type args struct { cc *ClientConn - t *Transaction + t Transaction } tests := []struct { name string args args wantRes []Transaction - wantErr assert.ErrorAssertionFunc }{ { name: "when action is create user without required permission", @@ -2088,18 +1885,20 @@ func TestHandleUpdateUser(t *testing.T) { cc: &ClientConn{ logger: NewTestLogger(), Server: &Server{ + AccountManager: func() *MockAccountManager { + m := MockAccountManager{} + m.On("Get", "bbb").Return((*Account)(nil)) + return &m + }(), Logger: NewTestLogger(), }, Account: &Account{ - Access: func() accessBitmap { - var bits accessBitmap - return bits - }(), + Access: accessBitmap{}, }, }, t: NewTransaction( TranUpdateUser, - &[]byte{0, 0}, + [2]byte{0, 0}, NewField(FieldData, []byte{ 0x00, 0x04, // field count @@ -2123,17 +1922,13 @@ func TestHandleUpdateUser(t *testing.T) { }, wantRes: []Transaction{ { - Flags: 0x00, IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0x9a, 0xcb, 0x04, 0x42}, - ErrorCode: []byte{0, 0, 0, 1}, + ErrorCode: [4]byte{0, 0, 0, 1}, Fields: []Field{ NewField(FieldError, []byte("You are not allowed to create new accounts.")), }, }, }, - wantErr: assert.NoError, }, { name: "when action is modify user without required permission", @@ -2142,9 +1937,11 @@ func TestHandleUpdateUser(t *testing.T) { logger: NewTestLogger(), Server: &Server{ Logger: NewTestLogger(), - Accounts: map[string]*Account{ - "bbb": {}, - }, + AccountManager: func() *MockAccountManager { + m := MockAccountManager{} + m.On("Get", "bbb").Return(&Account{}) + return &m + }(), }, Account: &Account{ Access: func() accessBitmap { @@ -2155,7 +1952,7 @@ func TestHandleUpdateUser(t *testing.T) { }, t: NewTransaction( TranUpdateUser, - &[]byte{0, 0}, + [2]byte{0, 0}, NewField(FieldData, []byte{ 0x00, 0x04, // field count @@ -2179,38 +1976,27 @@ func TestHandleUpdateUser(t *testing.T) { }, wantRes: []Transaction{ { - Flags: 0x00, IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0x9a, 0xcb, 0x04, 0x42}, - ErrorCode: []byte{0, 0, 0, 1}, + ErrorCode: [4]byte{0, 0, 0, 1}, Fields: []Field{ NewField(FieldError, []byte("You are not allowed to modify accounts.")), }, }, }, - wantErr: assert.NoError, }, { name: "when action is delete user without required permission", args: args{ cc: &ClientConn{ logger: NewTestLogger(), - Server: &Server{ - Accounts: map[string]*Account{ - "bbb": {}, - }, - }, + Server: &Server{}, Account: &Account{ - Access: func() accessBitmap { - var bits accessBitmap - return bits - }(), + Access: accessBitmap{}, }, }, t: NewTransaction( TranUpdateUser, - &[]byte{0, 0}, + [2]byte{0, 0}, NewField(FieldData, []byte{ 0x00, 0x01, 0x00, 0x65, @@ -2221,26 +2007,18 @@ func TestHandleUpdateUser(t *testing.T) { }, wantRes: []Transaction{ { - Flags: 0x00, IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0x9a, 0xcb, 0x04, 0x42}, - ErrorCode: []byte{0, 0, 0, 1}, + ErrorCode: [4]byte{0, 0, 0, 1}, Fields: []Field{ NewField(FieldError, []byte("You are not allowed to delete accounts.")), }, }, }, - wantErr: assert.NoError, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - gotRes, err := HandleUpdateUser(tt.args.cc, tt.args.t) - if !tt.wantErr(t, err, fmt.Sprintf("HandleUpdateUser(%v, %v)", tt.args.cc, tt.args.t)) { - return - } - + gotRes := HandleUpdateUser(tt.args.cc, &tt.args.t) tranAssertEqual(t, tt.wantRes, gotRes) }) } @@ -2249,13 +2027,12 @@ func TestHandleUpdateUser(t *testing.T) { func TestHandleDelNewsArt(t *testing.T) { type args struct { cc *ClientConn - t *Transaction + t Transaction } tests := []struct { name string args args wantRes []Transaction - wantErr assert.ErrorAssertionFunc }{ { name: "without required permission", @@ -2270,30 +2047,23 @@ func TestHandleDelNewsArt(t *testing.T) { }, t: NewTransaction( TranDelNewsArt, - &[]byte{0, 0}, + [2]byte{0, 0}, ), }, wantRes: []Transaction{ { - Flags: 0x00, IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0x9a, 0xcb, 0x04, 0x42}, - ErrorCode: []byte{0, 0, 0, 1}, + ErrorCode: [4]byte{0, 0, 0, 1}, Fields: []Field{ NewField(FieldError, []byte("You are not allowed to delete news articles.")), }, }, }, - wantErr: assert.NoError, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - gotRes, err := HandleDelNewsArt(tt.args.cc, tt.args.t) - if !tt.wantErr(t, err, fmt.Sprintf("HandleDelNewsArt(%v, %v)", tt.args.cc, tt.args.t)) { - return - } + gotRes := HandleDelNewsArt(tt.args.cc, &tt.args.t) tranAssertEqual(t, tt.wantRes, gotRes) }) } @@ -2302,13 +2072,12 @@ func TestHandleDelNewsArt(t *testing.T) { func TestHandleDisconnectUser(t *testing.T) { type args struct { cc *ClientConn - t *Transaction + t Transaction } tests := []struct { name string args args wantRes []Transaction - wantErr assert.ErrorAssertionFunc }{ { name: "without required permission", @@ -2323,76 +2092,68 @@ func TestHandleDisconnectUser(t *testing.T) { }, t: NewTransaction( TranDelNewsArt, - &[]byte{0, 0}, + [2]byte{0, 0}, ), }, wantRes: []Transaction{ { - Flags: 0x00, IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0x9a, 0xcb, 0x04, 0x42}, - ErrorCode: []byte{0, 0, 0, 1}, + ErrorCode: [4]byte{0, 0, 0, 1}, Fields: []Field{ NewField(FieldError, []byte("You are not allowed to disconnect users.")), }, }, }, - wantErr: assert.NoError, }, { name: "when target user has 'cannot be disconnected' priv", args: args{ cc: &ClientConn{ Server: &Server{ - Clients: map[uint16]*ClientConn{ - uint16(1): { + ClientMgr: func() *MockClientMgr { + m := MockClientMgr{} + m.On("Get", ClientID{0x0, 0x1}).Return(&ClientConn{ Account: &Account{ Login: "unnamed", Access: func() accessBitmap { var bits accessBitmap - bits.Set(accessCannotBeDiscon) + bits.Set(AccessCannotBeDiscon) return bits }(), }, }, - }, + ) + return &m + }(), }, Account: &Account{ Access: func() accessBitmap { var bits accessBitmap - bits.Set(accessDisconUser) + bits.Set(AccessDisconUser) return bits }(), }, }, t: NewTransaction( TranDelNewsArt, - &[]byte{0, 0}, + [2]byte{0, 0}, NewField(FieldUserID, []byte{0, 1}), ), }, wantRes: []Transaction{ { - Flags: 0x00, IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0x9a, 0xcb, 0x04, 0x42}, - ErrorCode: []byte{0, 0, 0, 1}, + ErrorCode: [4]byte{0, 0, 0, 1}, Fields: []Field{ NewField(FieldError, []byte("unnamed is not allowed to be disconnected.")), }, }, }, - wantErr: assert.NoError, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - gotRes, err := HandleDisconnectUser(tt.args.cc, tt.args.t) - if !tt.wantErr(t, err, fmt.Sprintf("HandleDisconnectUser(%v, %v)", tt.args.cc, tt.args.t)) { - return - } + gotRes := HandleDisconnectUser(tt.args.cc, &tt.args.t) tranAssertEqual(t, tt.wantRes, gotRes) }) } @@ -2401,13 +2162,12 @@ func TestHandleDisconnectUser(t *testing.T) { func TestHandleSendInstantMsg(t *testing.T) { type args struct { cc *ClientConn - t *Transaction + t Transaction } tests := []struct { name string args args wantRes []Transaction - wantErr assert.ErrorAssertionFunc }{ { name: "without required permission", @@ -2422,22 +2182,18 @@ func TestHandleSendInstantMsg(t *testing.T) { }, t: NewTransaction( TranDelNewsArt, - &[]byte{0, 0}, + [2]byte{0, 0}, ), }, wantRes: []Transaction{ { - Flags: 0x00, IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0, 0, 0, 0}, - ErrorCode: []byte{0, 0, 0, 1}, + ErrorCode: [4]byte{0, 0, 0, 1}, Fields: []Field{ NewField(FieldError, []byte("You are not allowed to send private messages.")), }, }, }, - wantErr: assert.Error, }, { name: "when client 1 sends a message to client 2", @@ -2446,48 +2202,46 @@ func TestHandleSendInstantMsg(t *testing.T) { Account: &Account{ Access: func() accessBitmap { var bits accessBitmap - bits.Set(accessSendPrivMsg) + bits.Set(AccessSendPrivMsg) return bits }(), }, - ID: &[]byte{0, 1}, + ID: [2]byte{0, 1}, UserName: []byte("User1"), Server: &Server{ - Clients: map[uint16]*ClientConn{ - uint16(2): { + ClientMgr: func() *MockClientMgr { + m := MockClientMgr{} + m.On("Get", ClientID{0x0, 0x2}).Return(&ClientConn{ AutoReply: []byte(nil), - Flags: []byte{0, 0}, + Flags: [2]byte{0, 0}, }, - }, + ) + return &m + }(), }, }, t: NewTransaction( TranSendInstantMsg, - &[]byte{0, 1}, + [2]byte{0, 1}, NewField(FieldData, []byte("hai")), NewField(FieldUserID, []byte{0, 2}), ), }, wantRes: []Transaction{ - *NewTransaction( + NewTransaction( TranServerMsg, - &[]byte{0, 2}, + [2]byte{0, 2}, NewField(FieldData, []byte("hai")), NewField(FieldUserName, []byte("User1")), NewField(FieldUserID, []byte{0, 1}), NewField(FieldOptions, []byte{0, 1}), ), { - clientID: &[]byte{0, 1}, - Flags: 0x00, - IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0, 0, 0, 0}, - ErrorCode: []byte{0, 0, 0, 0}, - Fields: []Field(nil), + clientID: [2]byte{0, 1}, + IsReply: 0x01, + Fields: []Field(nil), }, }, - wantErr: assert.NoError, }, { name: "when client 2 has autoreply enabled", @@ -2496,58 +2250,55 @@ func TestHandleSendInstantMsg(t *testing.T) { Account: &Account{ Access: func() accessBitmap { var bits accessBitmap - bits.Set(accessSendPrivMsg) + bits.Set(AccessSendPrivMsg) return bits }(), }, - ID: &[]byte{0, 1}, + ID: [2]byte{0, 1}, UserName: []byte("User1"), Server: &Server{ - Clients: map[uint16]*ClientConn{ - uint16(2): { - Flags: []byte{0, 0}, - ID: &[]byte{0, 2}, + ClientMgr: func() *MockClientMgr { + m := MockClientMgr{} + m.On("Get", ClientID{0x0, 0x2}).Return(&ClientConn{ + Flags: [2]byte{0, 0}, + ID: [2]byte{0, 2}, UserName: []byte("User2"), AutoReply: []byte("autohai"), - }, - }, + }) + return &m + }(), }, }, t: NewTransaction( TranSendInstantMsg, - &[]byte{0, 1}, + [2]byte{0, 1}, NewField(FieldData, []byte("hai")), NewField(FieldUserID, []byte{0, 2}), ), }, wantRes: []Transaction{ - *NewTransaction( + NewTransaction( TranServerMsg, - &[]byte{0, 2}, + [2]byte{0, 2}, NewField(FieldData, []byte("hai")), NewField(FieldUserName, []byte("User1")), NewField(FieldUserID, []byte{0, 1}), NewField(FieldOptions, []byte{0, 1}), ), - *NewTransaction( + NewTransaction( TranServerMsg, - &[]byte{0, 1}, + [2]byte{0, 1}, NewField(FieldData, []byte("autohai")), NewField(FieldUserName, []byte("User2")), NewField(FieldUserID, []byte{0, 2}), NewField(FieldOptions, []byte{0, 1}), ), { - clientID: &[]byte{0, 1}, - Flags: 0x00, - IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0, 0, 0, 0}, - ErrorCode: []byte{0, 0, 0, 0}, - Fields: []Field(nil), + clientID: [2]byte{0, 1}, + IsReply: 0x01, + Fields: []Field(nil), }, }, - wantErr: assert.NoError, }, { name: "when client 2 has refuse private messages enabled", @@ -2556,58 +2307,52 @@ func TestHandleSendInstantMsg(t *testing.T) { Account: &Account{ Access: func() accessBitmap { var bits accessBitmap - bits.Set(accessSendPrivMsg) + bits.Set(AccessSendPrivMsg) return bits }(), }, - ID: &[]byte{0, 1}, + ID: [2]byte{0, 1}, UserName: []byte("User1"), Server: &Server{ - Clients: map[uint16]*ClientConn{ - uint16(2): { - Flags: []byte{255, 255}, - ID: &[]byte{0, 2}, + ClientMgr: func() *MockClientMgr { + m := MockClientMgr{} + m.On("Get", ClientID{0x0, 0x2}).Return(&ClientConn{ + Flags: [2]byte{255, 255}, + ID: [2]byte{0, 2}, UserName: []byte("User2"), }, - }, + ) + return &m + }(), }, }, t: NewTransaction( TranSendInstantMsg, - &[]byte{0, 1}, + [2]byte{0, 1}, NewField(FieldData, []byte("hai")), NewField(FieldUserID, []byte{0, 2}), ), }, wantRes: []Transaction{ - *NewTransaction( + NewTransaction( TranServerMsg, - &[]byte{0, 1}, + [2]byte{0, 1}, NewField(FieldData, []byte("User2 does not accept private messages.")), NewField(FieldUserName, []byte("User2")), NewField(FieldUserID, []byte{0, 2}), NewField(FieldOptions, []byte{0, 2}), ), { - clientID: &[]byte{0, 1}, - Flags: 0x00, - IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0, 0, 0, 0}, - ErrorCode: []byte{0, 0, 0, 0}, - Fields: []Field(nil), + clientID: [2]byte{0, 1}, + IsReply: 0x01, + Fields: []Field(nil), }, }, - wantErr: assert.NoError, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - gotRes, err := HandleSendInstantMsg(tt.args.cc, tt.args.t) - if !tt.wantErr(t, err, fmt.Sprintf("HandleSendInstantMsg(%v, %v)", tt.args.cc, tt.args.t)) { - return - } - + gotRes := HandleSendInstantMsg(tt.args.cc, &tt.args.t) tranAssertEqual(t, tt.wantRes, gotRes) }) } @@ -2616,13 +2361,12 @@ func TestHandleSendInstantMsg(t *testing.T) { func TestHandleDeleteFile(t *testing.T) { type args struct { cc *ClientConn - t *Transaction + t Transaction } tests := []struct { name string args args wantRes []Transaction - wantErr assert.ErrorAssertionFunc }{ { name: "when user does not have required permission to delete a folder", @@ -2635,7 +2379,7 @@ func TestHandleDeleteFile(t *testing.T) { }(), }, Server: &Server{ - Config: &Config{ + Config: Config{ FileRoot: func() string { return "/fakeRoot/Files" }(), @@ -2655,11 +2399,11 @@ func TestHandleDeleteFile(t *testing.T) { return mfs }(), - Accounts: map[string]*Account{}, + //Accounts: map[string]*Account{}, }, }, t: NewTransaction( - TranDeleteFile, &[]byte{0, 1}, + TranDeleteFile, [2]byte{0, 1}, NewField(FieldFileName, []byte("testfile")), NewField(FieldFilePath, []byte{ 0x00, 0x01, @@ -2671,17 +2415,13 @@ func TestHandleDeleteFile(t *testing.T) { }, wantRes: []Transaction{ { - Flags: 0x00, IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0x9a, 0xcb, 0x04, 0x42}, - ErrorCode: []byte{0, 0, 0, 1}, + ErrorCode: [4]byte{0, 0, 0, 1}, Fields: []Field{ NewField(FieldError, []byte("You are not allowed to delete files.")), }, }, }, - wantErr: assert.NoError, }, { name: "deletes all associated metadata files", @@ -2690,12 +2430,12 @@ func TestHandleDeleteFile(t *testing.T) { Account: &Account{ Access: func() accessBitmap { var bits accessBitmap - bits.Set(accessDeleteFile) + bits.Set(AccessDeleteFile) return bits }(), }, Server: &Server{ - Config: &Config{ + Config: Config{ FileRoot: func() string { return "/fakeRoot/Files" }(), @@ -2720,11 +2460,11 @@ func TestHandleDeleteFile(t *testing.T) { return mfs }(), - Accounts: map[string]*Account{}, + //Accounts: map[string]*Account{}, }, }, t: NewTransaction( - TranDeleteFile, &[]byte{0, 1}, + TranDeleteFile, [2]byte{0, 1}, NewField(FieldFileName, []byte("testfile")), NewField(FieldFilePath, []byte{ 0x00, 0x01, @@ -2736,24 +2476,15 @@ func TestHandleDeleteFile(t *testing.T) { }, wantRes: []Transaction{ { - Flags: 0x00, - IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0x0, 0x0, 0x0, 0x0}, - ErrorCode: []byte{0, 0, 0, 0}, - Fields: []Field(nil), + IsReply: 0x01, + Fields: []Field(nil), }, }, - wantErr: assert.NoError, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - gotRes, err := HandleDeleteFile(tt.args.cc, tt.args.t) - if !tt.wantErr(t, err, fmt.Sprintf("HandleDeleteFile(%v, %v)", tt.args.cc, tt.args.t)) { - return - } - + gotRes := HandleDeleteFile(tt.args.cc, &tt.args.t) tranAssertEqual(t, tt.wantRes, gotRes) tt.args.cc.Server.FS.(*MockFileStore).AssertExpectations(t) @@ -2764,16 +2495,15 @@ func TestHandleDeleteFile(t *testing.T) { func TestHandleGetFileNameList(t *testing.T) { type args struct { cc *ClientConn - t *Transaction + t Transaction } tests := []struct { name string args args wantRes []Transaction - wantErr assert.ErrorAssertionFunc }{ { - name: "when FieldFilePath is a drop box, but user does not have accessViewDropBoxes ", + name: "when FieldFilePath is a drop box, but user does not have AccessViewDropBoxes ", args: args{ cc: &ClientConn{ Account: &Account{ @@ -2784,7 +2514,7 @@ func TestHandleGetFileNameList(t *testing.T) { }, Server: &Server{ - Config: &Config{ + Config: Config{ FileRoot: func() string { path, _ := os.Getwd() return filepath.Join(path, "/test/config/Files/getFileNameListTestDir") @@ -2793,7 +2523,7 @@ func TestHandleGetFileNameList(t *testing.T) { }, }, t: NewTransaction( - TranGetFileNameList, &[]byte{0, 1}, + TranGetFileNameList, [2]byte{0, 1}, NewField(FieldFilePath, []byte{ 0x00, 0x01, 0x00, 0x00, @@ -2804,24 +2534,20 @@ func TestHandleGetFileNameList(t *testing.T) { }, wantRes: []Transaction{ { - Flags: 0x00, IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0, 0, 0, 0}, - ErrorCode: []byte{0, 0, 0, 1}, + ErrorCode: [4]byte{0, 0, 0, 1}, Fields: []Field{ NewField(FieldError, []byte("You are not allowed to view drop boxes.")), }, }, }, - wantErr: assert.NoError, }, { name: "with file root", args: args{ cc: &ClientConn{ Server: &Server{ - Config: &Config{ + Config: Config{ FileRoot: func() string { path, _ := os.Getwd() return filepath.Join(path, "/test/config/Files/getFileNameListTestDir") @@ -2830,7 +2556,7 @@ func TestHandleGetFileNameList(t *testing.T) { }, }, t: NewTransaction( - TranGetFileNameList, &[]byte{0, 1}, + TranGetFileNameList, [2]byte{0, 1}, NewField(FieldFilePath, []byte{ 0x00, 0x00, 0x00, 0x00, @@ -2839,11 +2565,7 @@ func TestHandleGetFileNameList(t *testing.T) { }, wantRes: []Transaction{ { - Flags: 0x00, - IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0, 0, 0, 0}, - ErrorCode: []byte{0, 0, 0, 0}, + IsReply: 0x01, Fields: []Field{ NewField( FieldFileNameWithInfo, @@ -2857,25 +2579,20 @@ func TestHandleGetFileNameList(t *testing.T) { NameScript: [2]byte{}, NameSize: [2]byte{0, 0x0b}, }, - name: []byte("testfile-1k"), + Name: []byte("testfile-1k"), } - b, _ := fnwi.MarshalBinary() + b, _ := io.ReadAll(&fnwi) return b }(), ), }, }, }, - wantErr: assert.NoError, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - gotRes, err := HandleGetFileNameList(tt.args.cc, tt.args.t) - if !tt.wantErr(t, err, fmt.Sprintf("HandleGetFileNameList(%v, %v)", tt.args.cc, tt.args.t)) { - return - } - + gotRes := HandleGetFileNameList(tt.args.cc, &tt.args.t) tranAssertEqual(t, tt.wantRes, gotRes) }) } @@ -2884,13 +2601,12 @@ func TestHandleGetFileNameList(t *testing.T) { func TestHandleGetClientInfoText(t *testing.T) { type args struct { cc *ClientConn - t *Transaction + t Transaction } tests := []struct { name string args args wantRes []Transaction - wantErr assert.ErrorAssertionFunc }{ { name: "when user does not have required permission", @@ -2903,27 +2619,23 @@ func TestHandleGetClientInfoText(t *testing.T) { }(), }, Server: &Server{ - Accounts: map[string]*Account{}, + //Accounts: map[string]*Account{}, }, }, t: NewTransaction( - TranGetClientInfoText, &[]byte{0, 1}, + TranGetClientInfoText, [2]byte{0, 1}, NewField(FieldUserID, []byte{0, 1}), ), }, wantRes: []Transaction{ { - Flags: 0x00, IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0, 0, 0, 0}, - ErrorCode: []byte{0, 0, 0, 1}, + ErrorCode: [4]byte{0, 0, 0, 1}, Fields: []Field{ NewField(FieldError, []byte("You are not allowed to get client info.")), }, }, }, - wantErr: assert.NoError, }, { name: "with a valid user", @@ -2934,49 +2646,42 @@ func TestHandleGetClientInfoText(t *testing.T) { Account: &Account{ Access: func() accessBitmap { var bits accessBitmap - bits.Set(accessGetClientInfo) + bits.Set(AccessGetClientInfo) return bits }(), Name: "test", Login: "test", }, Server: &Server{ - Accounts: map[string]*Account{}, - Clients: map[uint16]*ClientConn{ - uint16(1): { + ClientMgr: func() *MockClientMgr { + m := MockClientMgr{} + m.On("Get", ClientID{0x0, 0x1}).Return(&ClientConn{ UserName: []byte("Testy McTest"), RemoteAddr: "1.2.3.4:12345", Account: &Account{ Access: func() accessBitmap { var bits accessBitmap - bits.Set(accessGetClientInfo) + bits.Set(AccessGetClientInfo) return bits }(), Name: "test", Login: "test", }, }, - }, - }, - transfers: map[int]map[[4]byte]*FileTransfer{ - FileDownload: {}, - FileUpload: {}, - FolderDownload: {}, - FolderUpload: {}, + ) + return &m + }(), }, + ClientFileTransferMgr: ClientFileTransferMgr{}, }, t: NewTransaction( - TranGetClientInfoText, &[]byte{0, 1}, + TranGetClientInfoText, [2]byte{0, 1}, NewField(FieldUserID, []byte{0, 1}), ), }, wantRes: []Transaction{ { - Flags: 0x00, - IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0, 0, 0, 0}, - ErrorCode: []byte{0, 0, 0, 0}, + IsReply: 0x01, Fields: []Field{ NewField(FieldData, []byte( strings.ReplaceAll(`Nickname: Testy McTest @@ -3010,15 +2715,11 @@ None. }, }, }, - wantErr: assert.NoError, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - gotRes, err := HandleGetClientInfoText(tt.args.cc, tt.args.t) - if !tt.wantErr(t, err, fmt.Sprintf("HandleGetClientInfoText(%v, %v)", tt.args.cc, tt.args.t)) { - return - } + gotRes := HandleGetClientInfoText(tt.args.cc, &tt.args.t) tranAssertEqual(t, tt.wantRes, gotRes) }) } @@ -3027,13 +2728,12 @@ None. func TestHandleTranAgreed(t *testing.T) { type args struct { cc *ClientConn - t *Transaction + t Transaction } tests := []struct { name string args args wantRes []Transaction - wantErr assert.ErrorAssertionFunc }{ { name: "normal request flow", @@ -3042,23 +2742,34 @@ func TestHandleTranAgreed(t *testing.T) { Account: &Account{ Access: func() accessBitmap { var bits accessBitmap - bits.Set(accessDisconUser) - bits.Set(accessAnyName) + bits.Set(AccessDisconUser) + bits.Set(AccessAnyName) return bits }()}, Icon: []byte{0, 1}, - Flags: []byte{0, 1}, + Flags: [2]byte{0, 1}, Version: []byte{0, 1}, - ID: &[]byte{0, 1}, + ID: [2]byte{0, 1}, logger: NewTestLogger(), Server: &Server{ - Config: &Config{ + Config: Config{ BannerFile: "banner.jpg", }, + ClientMgr: func() *MockClientMgr { + m := MockClientMgr{} + m.On("List").Return([]*ClientConn{ + //{ + // ID: [2]byte{0, 2}, + // UserName: []byte("UserB"), + //}, + }, + ) + return &m + }(), }, }, t: NewTransaction( - TranAgreed, nil, + TranAgreed, [2]byte{}, NewField(FieldUserName, []byte("username")), NewField(FieldUserIconID, []byte{0, 1}), NewField(FieldOptions, []byte{0, 0}), @@ -3066,35 +2777,23 @@ func TestHandleTranAgreed(t *testing.T) { }, wantRes: []Transaction{ { - clientID: &[]byte{0, 1}, - Flags: 0x00, - IsReply: 0x00, - Type: []byte{0, 0x7a}, - ID: []byte{0, 0, 0, 0}, - ErrorCode: []byte{0, 0, 0, 0}, + clientID: [2]byte{0, 1}, + Type: [2]byte{0, 0x7a}, Fields: []Field{ NewField(FieldBannerType, []byte("JPEG")), }, }, { - clientID: &[]byte{0, 1}, - Flags: 0x00, - IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0, 0, 0, 0}, - ErrorCode: []byte{0, 0, 0, 0}, - Fields: []Field{}, + clientID: [2]byte{0, 1}, + IsReply: 0x01, + Fields: []Field{}, }, }, - wantErr: assert.NoError, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - gotRes, err := HandleTranAgreed(tt.args.cc, tt.args.t) - if !tt.wantErr(t, err, fmt.Sprintf("HandleTranAgreed(%v, %v)", tt.args.cc, tt.args.t)) { - return - } + gotRes := HandleTranAgreed(tt.args.cc, &tt.args.t) tranAssertEqual(t, tt.wantRes, gotRes) }) } @@ -3103,16 +2802,15 @@ func TestHandleTranAgreed(t *testing.T) { func TestHandleSetClientUserInfo(t *testing.T) { type args struct { cc *ClientConn - t *Transaction + t Transaction } tests := []struct { name string args args wantRes []Transaction - wantErr assert.ErrorAssertionFunc }{ { - name: "when client does not have accessAnyName", + name: "when client does not have AccessAnyName", args: args{ cc: &ClientConn{ Account: &Account{ @@ -3121,31 +2819,31 @@ func TestHandleSetClientUserInfo(t *testing.T) { return bits }(), }, - ID: &[]byte{0, 1}, + ID: [2]byte{0, 1}, UserName: []byte("Guest"), - Flags: []byte{0, 1}, + Flags: [2]byte{0, 1}, Server: &Server{ - Clients: map[uint16]*ClientConn{ - uint16(1): { - ID: &[]byte{0, 1}, - }, - }, + ClientMgr: func() *MockClientMgr { + m := MockClientMgr{} + m.On("List").Return([]*ClientConn{ + { + ID: [2]byte{0, 1}, + }, + }) + return &m + }(), }, }, t: NewTransaction( - TranSetClientUserInfo, nil, + TranSetClientUserInfo, [2]byte{}, NewField(FieldUserIconID, []byte{0, 1}), NewField(FieldUserName, []byte("NOPE")), ), }, wantRes: []Transaction{ { - clientID: &[]byte{0, 1}, - Flags: 0x00, - IsReply: 0x00, - Type: []byte{0x01, 0x2d}, - ID: []byte{0, 0, 0, 0}, - ErrorCode: []byte{0, 0, 0, 0}, + clientID: [2]byte{0, 1}, + Type: [2]byte{0x01, 0x2d}, Fields: []Field{ NewField(FieldUserID, []byte{0, 1}), NewField(FieldUserIconID, []byte{0, 1}), @@ -3153,16 +2851,11 @@ func TestHandleSetClientUserInfo(t *testing.T) { NewField(FieldUserName, []byte("Guest"))}, }, }, - wantErr: assert.NoError, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - gotRes, err := HandleSetClientUserInfo(tt.args.cc, tt.args.t) - if !tt.wantErr(t, err, fmt.Sprintf("HandleSetClientUserInfo(%v, %v)", tt.args.cc, tt.args.t)) { - return - } - + gotRes := HandleSetClientUserInfo(tt.args.cc, &tt.args.t) tranAssertEqual(t, tt.wantRes, gotRes) }) } @@ -3171,13 +2864,12 @@ func TestHandleSetClientUserInfo(t *testing.T) { func TestHandleDelNewsItem(t *testing.T) { type args struct { cc *ClientConn - t *Transaction + t Transaction } tests := []struct { name string args args wantRes []Transaction - wantErr assert.ErrorAssertionFunc }{ { name: "when user does not have permission to delete a news category", @@ -3186,20 +2878,19 @@ func TestHandleDelNewsItem(t *testing.T) { Account: &Account{ Access: accessBitmap{}, }, - ID: &[]byte{0, 1}, + ID: [2]byte{0, 1}, Server: &Server{ - ThreadedNews: &ThreadedNews{Categories: map[string]NewsCategoryListData15{ - "test": { - Type: []byte{0, 3}, - Count: nil, - NameSize: 0, - Name: "zz", - }, - }}, + ThreadedNewsMgr: func() *mockThreadNewsMgr { + m := mockThreadNewsMgr{} + m.On("NewsItem", []string{"test"}).Return(NewsCategoryListData15{ + Type: NewsCategory, + }) + return &m + }(), }, }, t: NewTransaction( - TranDelNewsItem, nil, + TranDelNewsItem, [2]byte{}, NewField(FieldNewsPath, []byte{ 0, 1, @@ -3212,18 +2903,14 @@ func TestHandleDelNewsItem(t *testing.T) { }, wantRes: []Transaction{ { - clientID: &[]byte{0, 1}, - Flags: 0x00, + clientID: [2]byte{0, 1}, IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0, 0, 0, 0}, - ErrorCode: []byte{0, 0, 0, 1}, + ErrorCode: [4]byte{0, 0, 0, 1}, Fields: []Field{ NewField(FieldError, []byte("You are not allowed to delete news categories.")), }, }, }, - wantErr: assert.NoError, }, { name: "when user does not have permission to delete a news folder", @@ -3232,20 +2919,19 @@ func TestHandleDelNewsItem(t *testing.T) { Account: &Account{ Access: accessBitmap{}, }, - ID: &[]byte{0, 1}, + ID: [2]byte{0, 1}, Server: &Server{ - ThreadedNews: &ThreadedNews{Categories: map[string]NewsCategoryListData15{ - "testcat": { - Type: []byte{0, 2}, - Count: nil, - NameSize: 0, - Name: "test", - }, - }}, + ThreadedNewsMgr: func() *mockThreadNewsMgr { + m := mockThreadNewsMgr{} + m.On("NewsItem", []string{"test"}).Return(NewsCategoryListData15{ + Type: NewsBundle, + }) + return &m + }(), }, }, t: NewTransaction( - TranDelNewsItem, nil, + TranDelNewsItem, [2]byte{}, NewField(FieldNewsPath, []byte{ 0, 1, @@ -3258,18 +2944,14 @@ func TestHandleDelNewsItem(t *testing.T) { }, wantRes: []Transaction{ { - clientID: &[]byte{0, 1}, - Flags: 0x00, + clientID: [2]byte{0, 1}, IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0, 0, 0, 0}, - ErrorCode: []byte{0, 0, 0, 1}, + ErrorCode: [4]byte{0, 0, 0, 1}, Fields: []Field{ NewField(FieldError, []byte("You are not allowed to delete news folders.")), }, }, }, - wantErr: assert.NoError, }, { name: "when user deletes a news folder", @@ -3278,30 +2960,22 @@ func TestHandleDelNewsItem(t *testing.T) { Account: &Account{ Access: func() accessBitmap { var bits accessBitmap - bits.Set(accessNewsDeleteFldr) + bits.Set(AccessNewsDeleteFldr) return bits }(), }, - ID: &[]byte{0, 1}, + ID: [2]byte{0, 1}, Server: &Server{ - ConfigDir: "/fakeConfigRoot", - FS: func() *MockFileStore { - mfs := &MockFileStore{} - mfs.On("WriteFile", "/fakeConfigRoot/ThreadedNews.yaml", mock.Anything, mock.Anything).Return(nil, os.ErrNotExist) - return mfs + ThreadedNewsMgr: func() *mockThreadNewsMgr { + m := mockThreadNewsMgr{} + m.On("NewsItem", []string{"test"}).Return(NewsCategoryListData15{Type: NewsBundle}) + m.On("DeleteNewsItem", []string{"test"}).Return(nil) + return &m }(), - ThreadedNews: &ThreadedNews{Categories: map[string]NewsCategoryListData15{ - "testcat": { - Type: []byte{0, 2}, - Count: nil, - NameSize: 0, - Name: "test", - }, - }}, }, }, t: NewTransaction( - TranDelNewsItem, nil, + TranDelNewsItem, [2]byte{}, NewField(FieldNewsPath, []byte{ 0, 1, @@ -3314,89 +2988,16 @@ func TestHandleDelNewsItem(t *testing.T) { }, wantRes: []Transaction{ { - clientID: &[]byte{0, 1}, - Flags: 0x00, - IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0, 0, 0, 0}, - ErrorCode: []byte{0, 0, 0, 0}, - Fields: []Field{}, - }, - }, - wantErr: assert.NoError, - }, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - gotRes, err := HandleDelNewsItem(tt.args.cc, tt.args.t) - if !tt.wantErr(t, err, fmt.Sprintf("HandleDelNewsItem(%v, %v)", tt.args.cc, tt.args.t)) { - return - } - tranAssertEqual(t, tt.wantRes, gotRes) - }) - } -} - -func TestHandleDownloadBanner(t *testing.T) { - type args struct { - cc *ClientConn - t *Transaction - } - tests := []struct { - name string - args args - wantRes []Transaction - wantErr assert.ErrorAssertionFunc - }{ - { - name: "returns expected response", - args: args{ - cc: &ClientConn{ - ID: &[]byte{0, 1}, - transfers: map[int]map[[4]byte]*FileTransfer{ - bannerDownload: {}, - }, - Server: &Server{ - ConfigDir: "/config", - Config: &Config{ - BannerFile: "banner.jpg", - }, - fileTransfers: map[[4]byte]*FileTransfer{}, - FS: func() *MockFileStore { - mfi := &MockFileInfo{} - mfi.On("Size").Return(int64(100)) - - mfs := &MockFileStore{} - mfs.On("Stat", "/config/banner.jpg").Return(mfi, nil) - return mfs - }(), - }, - }, - t: NewTransaction(TranDownloadBanner, nil), - }, - wantRes: []Transaction{ - { - clientID: &[]byte{0, 1}, - Flags: 0x00, - IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0, 0, 0, 0}, - ErrorCode: []byte{0, 0, 0, 0}, - Fields: []Field{ - NewField(FieldRefNum, []byte{1, 2, 3, 4}), - NewField(FieldTransferSize, []byte{0, 0, 0, 0x64}), - }, + clientID: [2]byte{0, 1}, + IsReply: 0x01, + Fields: []Field{}, }, }, - wantErr: assert.NoError, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - gotRes, err := HandleDownloadBanner(tt.args.cc, tt.args.t) - if !tt.wantErr(t, err, fmt.Sprintf("HandleDownloadBanner(%v, %v)", tt.args.cc, tt.args.t)) { - return - } + gotRes := HandleDelNewsItem(tt.args.cc, &tt.args.t) tranAssertEqual(t, tt.wantRes, gotRes) }) @@ -3406,43 +3007,35 @@ func TestHandleDownloadBanner(t *testing.T) { func TestHandleTranOldPostNews(t *testing.T) { type args struct { cc *ClientConn - t *Transaction + t Transaction } tests := []struct { name string args args wantRes []Transaction - wantErr assert.ErrorAssertionFunc }{ { name: "when user does not have required permission", args: args{ cc: &ClientConn{ Account: &Account{ - Access: func() accessBitmap { - var bits accessBitmap - return bits - }(), + Access: accessBitmap{}, }, }, t: NewTransaction( - TranOldPostNews, &[]byte{0, 1}, + TranOldPostNews, [2]byte{0, 1}, NewField(FieldData, []byte("hai")), ), }, wantRes: []Transaction{ { - Flags: 0x00, IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0, 0, 0, 0}, - ErrorCode: []byte{0, 0, 0, 1}, + ErrorCode: [4]byte{0, 0, 0, 1}, Fields: []Field{ NewField(FieldError, []byte("You are not allowed to post news.")), }, }, }, - wantErr: assert.NoError, }, { name: "when user posts news update", @@ -3451,43 +3044,46 @@ func TestHandleTranOldPostNews(t *testing.T) { Account: &Account{ Access: func() accessBitmap { var bits accessBitmap - bits.Set(accessNewsPostArt) + bits.Set(AccessNewsPostArt) return bits }(), }, Server: &Server{ - FS: func() *MockFileStore { - mfs := &MockFileStore{} - mfs.On("WriteFile", "/fakeConfigRoot/MessageBoard.txt", mock.Anything, mock.Anything).Return(nil, os.ErrNotExist) - return mfs + Config: Config{ + NewsDateFormat: "", + }, + ClientMgr: func() *MockClientMgr { + m := MockClientMgr{} + m.On("List").Return([]*ClientConn{}) + return &m + }(), + MessageBoard: func() *mockReadWriteSeeker { + m := mockReadWriteSeeker{} + m.On("Seek", int64(0), 0).Return(int64(0), nil) + m.On("Read", mock.AnythingOfType("[]uint8")).Run(func(args mock.Arguments) { + arg := args.Get(0).([]uint8) + copy(arg, "TEST") + }).Return(4, io.EOF) + m.On("Write", mock.AnythingOfType("[]uint8")).Return(3, nil) + return &m }(), - ConfigDir: "/fakeConfigRoot", - Config: &Config{}, }, }, t: NewTransaction( - TranOldPostNews, &[]byte{0, 1}, + TranOldPostNews, [2]byte{0, 1}, NewField(FieldData, []byte("hai")), ), }, wantRes: []Transaction{ { - Flags: 0x00, - IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0, 0, 0, 0}, - ErrorCode: []byte{0, 0, 0, 0}, + IsReply: 0x01, }, }, - wantErr: assert.NoError, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - gotRes, err := HandleTranOldPostNews(tt.args.cc, tt.args.t) - if !tt.wantErr(t, err, fmt.Sprintf("HandleTranOldPostNews(%v, %v)", tt.args.cc, tt.args.t)) { - return - } + gotRes := HandleTranOldPostNews(tt.args.cc, &tt.args.t) tranAssertEqual(t, tt.wantRes, gotRes) }) @@ -3497,13 +3093,12 @@ func TestHandleTranOldPostNews(t *testing.T) { func TestHandleInviteNewChat(t *testing.T) { type args struct { cc *ClientConn - t *Transaction + t Transaction } tests := []struct { name string args args wantRes []Transaction - wantErr assert.ErrorAssertionFunc }{ { name: "when user does not have required permission", @@ -3516,75 +3111,67 @@ func TestHandleInviteNewChat(t *testing.T) { }(), }, }, - t: NewTransaction(TranInviteNewChat, &[]byte{0, 1}), + t: NewTransaction(TranInviteNewChat, [2]byte{0, 1}), }, wantRes: []Transaction{ { - Flags: 0x00, IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0, 0, 0, 0}, - ErrorCode: []byte{0, 0, 0, 1}, + ErrorCode: [4]byte{0, 0, 0, 1}, Fields: []Field{ NewField(FieldError, []byte("You are not allowed to request private chat.")), }, }, }, - wantErr: assert.NoError, }, { name: "when userA invites userB to new private chat", args: args{ cc: &ClientConn{ - ID: &[]byte{0, 1}, + ID: [2]byte{0, 1}, Account: &Account{ Access: func() accessBitmap { var bits accessBitmap - bits.Set(accessOpenChat) + bits.Set(AccessOpenChat) return bits }(), }, UserName: []byte("UserA"), Icon: []byte{0, 1}, - Flags: []byte{0, 0}, + Flags: [2]byte{0, 0}, Server: &Server{ - Clients: map[uint16]*ClientConn{ - uint16(2): { - ID: &[]byte{0, 2}, + ClientMgr: func() *MockClientMgr { + m := MockClientMgr{} + m.On("Get", ClientID{0x0, 0x2}).Return(&ClientConn{ + ID: [2]byte{0, 2}, UserName: []byte("UserB"), - Flags: []byte{0, 0}, - }, - }, - PrivateChats: make(map[uint32]*PrivateChat), + }) + return &m + }(), + ChatMgr: func() *MockChatManager { + m := MockChatManager{} + m.On("New", mock.AnythingOfType("*hotline.ClientConn")).Return(ChatID{0x52, 0xfd, 0xfc, 0x07}) + return &m + }(), }, }, t: NewTransaction( - TranInviteNewChat, &[]byte{0, 1}, + TranInviteNewChat, [2]byte{0, 1}, NewField(FieldUserID, []byte{0, 2}), ), }, wantRes: []Transaction{ { - clientID: &[]byte{0, 2}, - Flags: 0x00, - IsReply: 0x00, - Type: []byte{0, 0x71}, - ID: []byte{0, 0, 0, 0}, - ErrorCode: []byte{0, 0, 0, 0}, + clientID: [2]byte{0, 2}, + Type: [2]byte{0, 0x71}, Fields: []Field{ NewField(FieldChatID, []byte{0x52, 0xfd, 0xfc, 0x07}), NewField(FieldUserName, []byte("UserA")), NewField(FieldUserID, []byte{0, 1}), }, }, - { - clientID: &[]byte{0, 1}, - Flags: 0x00, - IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0, 0, 0, 0}, - ErrorCode: []byte{0, 0, 0, 0}, + clientID: [2]byte{0, 1}, + IsReply: 0x01, Fields: []Field{ NewField(FieldChatID, []byte{0x52, 0xfd, 0xfc, 0x07}), NewField(FieldUserName, []byte("UserA")), @@ -3594,47 +3181,49 @@ func TestHandleInviteNewChat(t *testing.T) { }, }, }, - wantErr: assert.NoError, }, { name: "when userA invites userB to new private chat, but UserB has refuse private chat enabled", args: args{ cc: &ClientConn{ - ID: &[]byte{0, 1}, + ID: [2]byte{0, 1}, Account: &Account{ Access: func() accessBitmap { var bits accessBitmap - bits.Set(accessOpenChat) + bits.Set(AccessOpenChat) return bits }(), }, UserName: []byte("UserA"), Icon: []byte{0, 1}, - Flags: []byte{0, 0}, + Flags: [2]byte{0, 0}, Server: &Server{ - Clients: map[uint16]*ClientConn{ - uint16(2): { - ID: &[]byte{0, 2}, + ClientMgr: func() *MockClientMgr { + m := MockClientMgr{} + m.On("Get", ClientID{0, 2}).Return(&ClientConn{ + ID: [2]byte{0, 2}, + Icon: []byte{0, 1}, UserName: []byte("UserB"), - Flags: []byte{255, 255}, - }, - }, - PrivateChats: make(map[uint32]*PrivateChat), + Flags: [2]byte{255, 255}, + }) + return &m + }(), + ChatMgr: func() *MockChatManager { + m := MockChatManager{} + m.On("New", mock.AnythingOfType("*hotline.ClientConn")).Return(ChatID{0x52, 0xfd, 0xfc, 0x07}) + return &m + }(), }, }, t: NewTransaction( - TranInviteNewChat, &[]byte{0, 1}, + TranInviteNewChat, [2]byte{0, 1}, NewField(FieldUserID, []byte{0, 2}), ), }, wantRes: []Transaction{ { - clientID: &[]byte{0, 1}, - Flags: 0x00, - IsReply: 0x00, - Type: []byte{0, 0x68}, - ID: []byte{0, 0, 0, 0}, - ErrorCode: []byte{0, 0, 0, 0}, + clientID: [2]byte{0, 1}, + Type: [2]byte{0, 0x68}, Fields: []Field{ NewField(FieldData, []byte("UserB does not accept private chats.")), NewField(FieldUserName, []byte("UserB")), @@ -3643,12 +3232,8 @@ func TestHandleInviteNewChat(t *testing.T) { }, }, { - clientID: &[]byte{0, 1}, - Flags: 0x00, - IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0, 0, 0, 0}, - ErrorCode: []byte{0, 0, 0, 0}, + clientID: [2]byte{0, 1}, + IsReply: 0x01, Fields: []Field{ NewField(FieldChatID, []byte{0x52, 0xfd, 0xfc, 0x07}), NewField(FieldUserName, []byte("UserA")), @@ -3658,16 +3243,13 @@ func TestHandleInviteNewChat(t *testing.T) { }, }, }, - wantErr: assert.NoError, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - rand.Seed(1) - gotRes, err := HandleInviteNewChat(tt.args.cc, tt.args.t) - if !tt.wantErr(t, err, fmt.Sprintf("HandleInviteNewChat(%v, %v)", tt.args.cc, tt.args.t)) { - return - } + + gotRes := HandleInviteNewChat(tt.args.cc, &tt.args.t) + tranAssertEqual(t, tt.wantRes, gotRes) }) } @@ -3676,53 +3258,90 @@ func TestHandleInviteNewChat(t *testing.T) { func TestHandleGetNewsArtData(t *testing.T) { type args struct { cc *ClientConn - t *Transaction + t Transaction } tests := []struct { name string args args wantRes []Transaction - wantErr assert.ErrorAssertionFunc }{ { name: "when user does not have required permission", + args: args{ + cc: &ClientConn{Account: &Account{}}, + t: NewTransaction( + TranGetNewsArtData, [2]byte{0, 1}, + ), + }, + wantRes: []Transaction{ + { + IsReply: 0x01, + ErrorCode: [4]byte{0, 0, 0, 1}, + Fields: []Field{ + NewField(FieldError, []byte("You are not allowed to read news.")), + }, + }, + }, + }, + { + name: "when user has required permission", args: args{ cc: &ClientConn{ Account: &Account{ Access: func() accessBitmap { var bits accessBitmap + bits.Set(AccessNewsReadArt) return bits }(), }, Server: &Server{ - Accounts: map[string]*Account{}, + ThreadedNewsMgr: func() *mockThreadNewsMgr { + m := mockThreadNewsMgr{} + m.On("GetArticle", []string{"Example Category"}, uint32(1)).Return(&NewsArtData{ + Title: "title", + Poster: "poster", + Date: [8]byte{}, + PrevArt: [4]byte{0, 0, 0, 1}, + NextArt: [4]byte{0, 0, 0, 2}, + ParentArt: [4]byte{0, 0, 0, 3}, + FirstChildArt: [4]byte{0, 0, 0, 4}, + DataFlav: []byte("text/plain"), + Data: "article data", + }) + return &m + }(), }, }, t: NewTransaction( - TranGetNewsArtData, &[]byte{0, 1}, + TranGetNewsArtData, [2]byte{0, 1}, + NewField(FieldNewsPath, []byte{ + // Example Category + 0x00, 0x01, 0x00, 0x00, 0x10, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x43, 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, 0x79, + }), + NewField(FieldNewsArtID, []byte{0, 1}), ), }, wantRes: []Transaction{ { - Flags: 0x00, - IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0x9a, 0xcb, 0x04, 0x42}, - ErrorCode: []byte{0, 0, 0, 1}, + IsReply: 1, Fields: []Field{ - NewField(FieldError, []byte("You are not allowed to read news.")), + NewField(FieldNewsArtTitle, []byte("title")), + NewField(FieldNewsArtPoster, []byte("poster")), + NewField(FieldNewsArtDate, []byte{0, 0, 0, 0, 0, 0, 0, 0}), + NewField(FieldNewsArtPrevArt, []byte{0, 0, 0, 1}), + NewField(FieldNewsArtNextArt, []byte{0, 0, 0, 2}), + NewField(FieldNewsArtParentArt, []byte{0, 0, 0, 3}), + NewField(FieldNewsArt1stChildArt, []byte{0, 0, 0, 4}), + NewField(FieldNewsArtDataFlav, []byte("text/plain")), + NewField(FieldNewsArtData, []byte("article data")), }, }, }, - wantErr: assert.NoError, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - gotRes, err := HandleGetNewsArtData(tt.args.cc, tt.args.t) - if !tt.wantErr(t, err, fmt.Sprintf("HandleGetNewsArtData(%v, %v)", tt.args.cc, tt.args.t)) { - return - } + gotRes := HandleGetNewsArtData(tt.args.cc, &tt.args.t) tranAssertEqual(t, tt.wantRes, gotRes) }) } @@ -3731,13 +3350,12 @@ func TestHandleGetNewsArtData(t *testing.T) { func TestHandleGetNewsArtNameList(t *testing.T) { type args struct { cc *ClientConn - t *Transaction + t Transaction } tests := []struct { name string args args wantRes []Transaction - wantErr assert.ErrorAssertionFunc }{ { name: "when user does not have required permission", @@ -3750,33 +3368,78 @@ func TestHandleGetNewsArtNameList(t *testing.T) { }(), }, Server: &Server{ - Accounts: map[string]*Account{}, + //Accounts: map[string]*Account{}, }, }, t: NewTransaction( - TranGetNewsArtNameList, &[]byte{0, 1}, + TranGetNewsArtNameList, [2]byte{0, 1}, ), }, wantRes: []Transaction{ { Flags: 0x00, IsReply: 0x01, - Type: []byte{0, 0}, - ErrorCode: []byte{0, 0, 0, 1}, + Type: [2]byte{0, 0}, + ErrorCode: [4]byte{0, 0, 0, 1}, Fields: []Field{ NewField(FieldError, []byte("You are not allowed to read news.")), }, }, }, - wantErr: assert.NoError, }, + //{ + // name: "when user has required access", + // args: args{ + // cc: &ClientConn{ + // Account: &Account{ + // Access: func() accessBitmap { + // var bits accessBitmap + // bits.Set(AccessNewsReadArt) + // return bits + // }(), + // }, + // Server: &Server{ + // ThreadedNewsMgr: func() *mockThreadNewsMgr { + // m := mockThreadNewsMgr{} + // m.On("ListArticles", []string{"Example Category"}).Return(NewsArtListData{ + // Name: []byte("testTitle"), + // NewsArtList: []byte{}, + // }) + // return &m + // }(), + // }, + // }, + // t: NewTransaction( + // TranGetNewsArtNameList, + // [2]byte{0, 1}, + // // 00000000 00 01 00 00 10 45 78 61 6d 70 6c 65 20 43 61 74 |.....Example Cat| + // // 00000010 65 67 6f 72 79 |egory| + // NewField(FieldNewsPath, []byte{ + // 0x00, 0x01, 0x00, 0x00, 0x10, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x43, 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, 0x79, + // }), + // ), + // }, + // wantRes: []Transaction{ + // { + // IsReply: 0x01, + // Fields: []Field{ + // NewField(FieldNewsArtListData, []byte{ + // 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, + // 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, + // 0x09, 0x74, 0x65, 0x73, 0x74, 0x54, 0x69, 0x74, 0x6c, 0x65, 0x0a, 0x74, 0x65, 0x73, 0x74, 0x50, + // 0x6f, 0x73, 0x74, 0x65, 0x72, 0x0a, 0x74, 0x65, 0x78, 0x74, 0x2f, 0x70, 0x6c, 0x61, 0x69, 0x6e, + // 0x00, 0x08, + // }, + // ), + // }, + // }, + // }, + //}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - gotRes, err := HandleGetNewsArtNameList(tt.args.cc, tt.args.t) - if !tt.wantErr(t, err, fmt.Sprintf("HandleGetNewsArtNameList(%v, %v)", tt.args.cc, tt.args.t)) { - return - } + gotRes := HandleGetNewsArtNameList(tt.args.cc, &tt.args.t) + tranAssertEqual(t, tt.wantRes, gotRes) }) } @@ -3785,13 +3448,12 @@ func TestHandleGetNewsArtNameList(t *testing.T) { func TestHandleNewNewsFldr(t *testing.T) { type args struct { cc *ClientConn - t *Transaction + t Transaction } tests := []struct { name string args args wantRes []Transaction - wantErr assert.ErrorAssertionFunc }{ { name: "when user does not have required permission", @@ -3804,25 +3466,24 @@ func TestHandleNewNewsFldr(t *testing.T) { }(), }, Server: &Server{ - Accounts: map[string]*Account{}, + //Accounts: map[string]*Account{}, }, }, t: NewTransaction( - TranGetNewsArtNameList, &[]byte{0, 1}, + TranGetNewsArtNameList, [2]byte{0, 1}, ), }, wantRes: []Transaction{ { Flags: 0x00, IsReply: 0x01, - Type: []byte{0, 0}, - ErrorCode: []byte{0, 0, 0, 1}, + Type: [2]byte{0, 0}, + ErrorCode: [4]byte{0, 0, 0, 1}, Fields: []Field{ NewField(FieldError, []byte("You are not allowed to create news folders.")), }, }, }, - wantErr: assert.NoError, }, { name: "with a valid request", @@ -3831,32 +3492,22 @@ func TestHandleNewNewsFldr(t *testing.T) { Account: &Account{ Access: func() accessBitmap { var bits accessBitmap - bits.Set(accessNewsCreateFldr) + bits.Set(AccessNewsCreateFldr) return bits }(), }, logger: NewTestLogger(), - ID: &[]byte{0, 1}, + ID: [2]byte{0, 1}, Server: &Server{ - ConfigDir: "/fakeConfigRoot", - FS: func() *MockFileStore { - mfs := &MockFileStore{} - mfs.On("WriteFile", "/fakeConfigRoot/ThreadedNews.yaml", mock.Anything, mock.Anything).Return(nil) - return mfs + ThreadedNewsMgr: func() *mockThreadNewsMgr { + m := mockThreadNewsMgr{} + m.On("CreateGrouping", []string{"test"}, "testFolder", NewsBundle).Return(nil) + return &m }(), - ThreadedNews: &ThreadedNews{Categories: map[string]NewsCategoryListData15{ - "test": { - Type: []byte{0, 2}, - Count: nil, - NameSize: 0, - Name: "test", - SubCats: make(map[string]NewsCategoryListData15), - }, - }}, }, }, t: NewTransaction( - TranGetNewsArtNameList, &[]byte{0, 1}, + TranGetNewsArtNameList, [2]byte{0, 1}, NewField(FieldFileName, []byte("testFolder")), NewField(FieldNewsPath, []byte{ @@ -3870,30 +3521,25 @@ func TestHandleNewNewsFldr(t *testing.T) { }, wantRes: []Transaction{ { - clientID: &[]byte{0, 1}, - Flags: 0x00, - IsReply: 0x01, - Type: []byte{0, 0}, - ID: []byte{0, 0, 0, 0}, - ErrorCode: []byte{0, 0, 0, 0}, - Fields: []Field{}, + clientID: [2]byte{0, 1}, + IsReply: 0x01, + Fields: []Field{}, }, }, - wantErr: assert.NoError, }, //{ - // name: "when there is an error writing the threaded news file", + // Name: "when there is an error writing the threaded news file", // args: args{ // cc: &ClientConn{ // Account: &Account{ // Access: func() accessBitmap { // var bits accessBitmap - // bits.Set(accessNewsCreateFldr) + // bits.Set(AccessNewsCreateFldr) // return bits // }(), // }, // logger: NewTestLogger(), - // ID: &[]byte{0, 1}, + // Type: [2]byte{0, 1}, // Server: &Server{ // ConfigDir: "/fakeConfigRoot", // FS: func() *MockFileStore { @@ -3913,7 +3559,7 @@ func TestHandleNewNewsFldr(t *testing.T) { // }, // }, // t: NewTransaction( - // TranGetNewsArtNameList, &[]byte{0, 1}, + // TranGetNewsArtNameList, [2]byte{0, 1}, // NewField(FieldFileName, []byte("testFolder")), // NewField(FieldNewsPath, // []byte{ @@ -3927,26 +3573,121 @@ func TestHandleNewNewsFldr(t *testing.T) { // }, // wantRes: []Transaction{ // { - // clientID: &[]byte{0, 1}, + // clientID: [2]byte{0, 1}, // Flags: 0x00, // IsReply: 0x01, - // Type: []byte{0, 0}, - // ErrorCode: []byte{0, 0, 0, 1}, + // Type: [2]byte{0, 0}, + // ErrorCode: [4]byte{0, 0, 0, 1}, // Fields: []Field{ // NewField(FieldError, []byte("Error creating news folder.")), // }, // }, // }, - // wantErr: assert.Error, - // }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - gotRes, err := HandleNewNewsFldr(tt.args.cc, tt.args.t) - if !tt.wantErr(t, err, fmt.Sprintf("HandleNewNewsFldr(%v, %v)", tt.args.cc, tt.args.t)) { - return - } + gotRes := HandleNewNewsFldr(tt.args.cc, &tt.args.t) + tranAssertEqual(t, tt.wantRes, gotRes) }) } } + +func TestHandleDownloadBanner(t *testing.T) { + type args struct { + cc *ClientConn + t Transaction + } + tests := []struct { + name string + args args + wantRes []Transaction + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + gotRes := HandleDownloadBanner(tt.args.cc, &tt.args.t) + + assert.Equalf(t, tt.wantRes, gotRes, "HandleDownloadBanner(%v, %v)", tt.args.cc, &tt.args.t) + }) + } +} + +func TestHandlePostNewsArt(t *testing.T) { + type args struct { + cc *ClientConn + t Transaction + } + tests := []struct { + name string + args args + wantRes []Transaction + }{ + { + name: "without required permission", + args: args{ + cc: &ClientConn{ + Account: &Account{ + Access: func() accessBitmap { + var bits accessBitmap + return bits + }(), + }, + }, + t: NewTransaction( + TranPostNewsArt, + [2]byte{0, 0}, + ), + }, + wantRes: []Transaction{ + { + IsReply: 0x01, + ErrorCode: [4]byte{0, 0, 0, 1}, + Fields: []Field{ + NewField(FieldError, []byte("You are not allowed to post news articles.")), + }, + }, + }, + }, + { + name: "with required permission", + args: args{ + cc: &ClientConn{ + Server: &Server{ + ThreadedNewsMgr: func() *mockThreadNewsMgr { + m := mockThreadNewsMgr{} + m.On("PostArticle", []string{"www"}, uint32(0), mock.AnythingOfType("hotline.NewsArtData")).Return(nil) + return &m + }(), + }, + Account: &Account{ + Access: func() accessBitmap { + var bits accessBitmap + bits.Set(AccessNewsPostArt) + return bits + }(), + }, + }, + t: NewTransaction( + TranPostNewsArt, + [2]byte{0, 0}, + NewField(FieldNewsPath, []byte{0x00, 0x01, 0x00, 0x00, 0x03, 0x77, 0x77, 0x77}), + NewField(FieldNewsArtID, []byte{0x00, 0x00, 0x00, 0x00}), + ), + }, + wantRes: []Transaction{ + { + IsReply: 0x01, + ErrorCode: [4]byte{0, 0, 0, 0}, + Fields: []Field{}, + }, + }, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + tranAssertEqual(t, tt.wantRes, HandlePostNewsArt(tt.args.cc, &tt.args.t)) + }) + } +}