X-Git-Url: https://git.r.bdr.sh/rbdr/mobius/blobdiff_plain/decc2fbf5db4a05aec93462ad35d890930bddd04..e130e0a2142f123d9d6f9351d0758289f010a1bb:/hotline/transaction_handlers_test.go diff --git a/hotline/transaction_handlers_test.go b/hotline/transaction_handlers_test.go index a83f4cc..9165a66 100644 --- a/hotline/transaction_handlers_test.go +++ b/hotline/transaction_handlers_test.go @@ -2,6 +2,7 @@ package hotline import ( "errors" + "fmt" "github.com/stretchr/testify/assert" "io/fs" "math/rand" @@ -302,6 +303,14 @@ func TestHandleChatSend(t *testing.T) { name: "sends chat msg transaction to all clients", args: args{ cc: &ClientConn{ + Account: &Account{ + Access: func() *[]byte { + var bits accessBitmap + bits.Set(accessSendChat) + access := bits[:] + return &access + }(), + }, UserName: []byte{0x00, 0x01}, Server: &Server{ Clients: map[uint16]*ClientConn{ @@ -352,10 +361,52 @@ func TestHandleChatSend(t *testing.T) { }, wantErr: false, }, + { + name: "when user does not have required permission", + args: args{ + cc: &ClientConn{ + Account: &Account{ + Access: func() *[]byte { + var bits accessBitmap + access := bits[:] + return &access + }(), + }, + Server: &Server{ + Accounts: map[string]*Account{}, + }, + }, + t: NewTransaction( + tranChatSend, &[]byte{0, 1}, + NewField(fieldData, []byte("hai")), + ), + }, + want: []Transaction{ + { + Flags: 0x00, + IsReply: 0x01, + Type: []byte{0, 0x00}, + ID: []byte{0x9a, 0xcb, 0x04, 0x42}, + ErrorCode: []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", args: args{ cc: &ClientConn{ + Account: &Account{ + Access: func() *[]byte { + var bits accessBitmap + bits.Set(accessSendChat) + access := bits[:] + return &access + }(), + }, UserName: []byte("Testy McTest"), Server: &Server{ Clients: map[uint16]*ClientConn{ @@ -387,7 +438,7 @@ func TestHandleChatSend(t *testing.T) { Flags: 0x00, IsReply: 0x00, Type: []byte{0, 0x6a}, - ID: []byte{0x9a, 0xcb, 0x04, 0x42}, // Random ID from rand.Seed(1) + ID: []byte{0x9a, 0xcb, 0x04, 0x42}, ErrorCode: []byte{0, 0, 0, 0}, Fields: []Field{ NewField(fieldData, []byte("\r*** Testy McTest performed action")), @@ -398,7 +449,7 @@ func TestHandleChatSend(t *testing.T) { Flags: 0x00, IsReply: 0x00, Type: []byte{0, 0x6a}, - ID: []byte{0xf0, 0xc5, 0x34, 0x1e}, // Random ID from rand.Seed(1) + ID: []byte{0xf0, 0xc5, 0x34, 0x1e}, ErrorCode: []byte{0, 0, 0, 0}, Fields: []Field{ NewField(fieldData, []byte("\r*** Testy McTest performed action")), @@ -411,6 +462,14 @@ func TestHandleChatSend(t *testing.T) { name: "only sends chat msg to clients with accessReadChat permission", args: args{ cc: &ClientConn{ + Account: &Account{ + Access: func() *[]byte { + var bits accessBitmap + bits.Set(accessSendChat) + access := bits[:] + return &access + }(), + }, UserName: []byte{0x00, 0x01}, Server: &Server{ Clients: map[uint16]*ClientConn{ @@ -450,9 +509,91 @@ func TestHandleChatSend(t *testing.T) { }, wantErr: false, }, + { + name: "only sends private chat msg to members of private chat", + args: args{ + cc: &ClientConn{ + Account: &Account{ + Access: func() *[]byte { + var bits accessBitmap + bits.Set(accessSendChat) + access := bits[:] + return &access + }(), + }, + 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}, + }, + }, + }, + }, + Clients: map[uint16]*ClientConn{ + uint16(1): { + Account: &Account{ + Access: &[]byte{255, 255, 255, 255, 255, 255, 255, 255}, + }, + ID: &[]byte{0, 1}, + }, + uint16(2): { + Account: &Account{ + Access: &[]byte{0, 0, 0, 0, 0, 0, 0, 0}, + }, + ID: &[]byte{0, 2}, + }, + uint16(3): { + Account: &Account{ + Access: &[]byte{0, 0, 0, 0, 0, 0, 0, 0}, + }, + ID: &[]byte{0, 3}, + }, + }, + }, + }, + t: &Transaction{ + Fields: []Field{ + NewField(fieldData, []byte("hai")), + NewField(fieldChatID, []byte{0, 0, 0, 1}), + }, + }, + }, + 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}, + 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}, + 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 { - rand.Seed(1) // reset seed between tests to make transaction IDs predictable t.Run(tt.name, func(t *testing.T) { got, err := HandleChatSend(tt.args.cc, tt.args.t) @@ -460,9 +601,7 @@ func TestHandleChatSend(t *testing.T) { t.Errorf("HandleChatSend() error = %v, wantErr %v", err, tt.wantErr) return } - if !assert.Equal(t, tt.want, got) { - t.Errorf("HandleChatSend() got = %v, want %v", got, tt.want) - } + tranAssertEqual(t, tt.want, got) }) } } @@ -579,7 +718,7 @@ func TestHandleNewFolder(t *testing.T) { ), }, setup: func() { - mfs := MockFileStore{} + mfs := &MockFileStore{} mfs.On("Mkdir", "/Files/aaa/testFolder", fs.FileMode(0777)).Return(nil) mfs.On("Stat", "/Files/aaa/testFolder").Return(nil, os.ErrNotExist) FS = mfs @@ -613,7 +752,7 @@ func TestHandleNewFolder(t *testing.T) { ), }, setup: func() { - mfs := MockFileStore{} + mfs := &MockFileStore{} mfs.On("Mkdir", "/Files/testFolder", fs.FileMode(0777)).Return(nil) mfs.On("Stat", "/Files/testFolder").Return(nil, os.ErrNotExist) FS = mfs @@ -650,7 +789,7 @@ func TestHandleNewFolder(t *testing.T) { ), }, setup: func() { - mfs := MockFileStore{} + mfs := &MockFileStore{} mfs.On("Mkdir", "/Files/aaa/testFolder", fs.FileMode(0777)).Return(nil) mfs.On("Stat", "/Files/aaa/testFolder").Return(nil, os.ErrNotExist) FS = mfs @@ -675,7 +814,7 @@ func TestHandleNewFolder(t *testing.T) { ), }, setup: func() { - mfs := MockFileStore{} + mfs := &MockFileStore{} mfs.On("Mkdir", "/Files/testFolder", fs.FileMode(0777)).Return(nil) mfs.On("Stat", "/Files/testFolder").Return(nil, os.ErrNotExist) FS = mfs @@ -717,7 +856,7 @@ func TestHandleNewFolder(t *testing.T) { ), }, setup: func() { - mfs := MockFileStore{} + mfs := &MockFileStore{} mfs.On("Mkdir", "/Files/foo/testFolder", fs.FileMode(0777)).Return(nil) mfs.On("Stat", "/Files/foo/testFolder").Return(nil, os.ErrNotExist) FS = mfs @@ -762,7 +901,7 @@ func TestHandleUploadFile(t *testing.T) { wantErr bool }{ { - name: "when request is valid", + name: "when request is valid and user has Upload Anywhere permission", args: args{ cc: &ClientConn{ Server: &Server{ @@ -772,6 +911,7 @@ func TestHandleUploadFile(t *testing.T) { Access: func() *[]byte { var bits accessBitmap bits.Set(accessUploadFile) + bits.Set(accessUploadAnywhere) access := bits[:] return &access }(), @@ -851,9 +991,9 @@ func TestHandleUploadFile(t *testing.T) { t.Errorf("HandleUploadFile() error = %v, wantErr %v", err, tt.wantErr) return } - if !tranAssertEqual(t, tt.wantRes, gotRes) { - t.Errorf("HandleUploadFile() gotRes = %v, want %v", gotRes, tt.wantRes) - } + + tranAssertEqual(t, tt.wantRes, gotRes) + }) } } @@ -873,7 +1013,7 @@ func TestHandleMakeAlias(t *testing.T) { { name: "with valid input and required permissions", setup: func() { - mfs := MockFileStore{} + mfs := &MockFileStore{} path, _ := os.Getwd() mfs.On( "Symlink", @@ -924,7 +1064,7 @@ func TestHandleMakeAlias(t *testing.T) { { name: "when symlink returns an error", setup: func() { - mfs := MockFileStore{} + mfs := &MockFileStore{} path, _ := os.Getwd() mfs.On( "Symlink", @@ -1041,3 +1181,729 @@ func TestHandleMakeAlias(t *testing.T) { }) } } + +func TestHandleGetUser(t *testing.T) { + type args struct { + cc *ClientConn + t *Transaction + } + tests := []struct { + name string + args args + wantRes []Transaction + wantErr assert.ErrorAssertionFunc + }{ + { + name: "when account is valid", + args: args{ + cc: &ClientConn{ + Account: &Account{ + Access: func() *[]byte { + var bits accessBitmap + bits.Set(accessOpenUser) + access := bits[:] + return &access + }(), + }, + Server: &Server{ + Accounts: map[string]*Account{ + "guest": { + Login: "guest", + Name: "Guest", + Password: "password", + Access: &[]byte{1}, + }, + }, + }, + }, + t: NewTransaction( + tranGetUser, &[]byte{0, 1}, + NewField(fieldUserLogin, []byte("guest")), + ), + }, + wantRes: []Transaction{ + { + Flags: 0x00, + IsReply: 0x01, + Type: []byte{0x01, 0x60}, + ID: []byte{0x9a, 0xcb, 0x04, 0x42}, + ErrorCode: []byte{0, 0, 0, 0}, + Fields: []Field{ + NewField(fieldUserName, []byte("Guest")), + NewField(fieldUserLogin, negateString([]byte("guest"))), + NewField(fieldUserPassword, []byte("password")), + NewField(fieldUserAccess, []byte{1}), + }, + }, + }, + wantErr: assert.NoError, + }, + { + name: "when user does not have required permission", + args: args{ + cc: &ClientConn{ + Account: &Account{ + Access: func() *[]byte { + var bits accessBitmap + access := bits[:] + return &access + }(), + }, + Server: &Server{ + Accounts: map[string]*Account{}, + }, + }, + t: NewTransaction( + tranGetUser, &[]byte{0, 1}, + NewField(fieldUserLogin, []byte("nonExistentUser")), + ), + }, + wantRes: []Transaction{ + { + Flags: 0x00, + IsReply: 0x01, + Type: []byte{0, 0x00}, + ID: []byte{0x9a, 0xcb, 0x04, 0x42}, + ErrorCode: []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", + args: args{ + cc: &ClientConn{ + Account: &Account{ + Access: func() *[]byte { + var bits accessBitmap + bits.Set(accessOpenUser) + access := bits[:] + return &access + }(), + }, + Server: &Server{ + Accounts: map[string]*Account{}, + }, + }, + t: NewTransaction( + tranGetUser, &[]byte{0, 1}, + NewField(fieldUserLogin, []byte("nonExistentUser")), + ), + }, + wantRes: []Transaction{ + { + Flags: 0x00, + IsReply: 0x01, + Type: []byte{0, 0x00}, + ID: []byte{0x9a, 0xcb, 0x04, 0x42}, + ErrorCode: []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 + } + + tranAssertEqual(t, tt.wantRes, gotRes) + }) + } +} + +func TestHandleDeleteUser(t *testing.T) { + type args struct { + cc *ClientConn + t *Transaction + } + tests := []struct { + name string + setup func() + args args + wantRes []Transaction + wantErr assert.ErrorAssertionFunc + }{ + { + name: "when user exists", + setup: func() { + mfs := &MockFileStore{} + mfs.On("Remove", "Users/testuser.yaml").Return(nil) + FS = mfs + }, + args: args{ + cc: &ClientConn{ + Account: &Account{ + Access: func() *[]byte { + var bits accessBitmap + bits.Set(accessDeleteUser) + access := bits[:] + return &access + }(), + }, + Server: &Server{ + Accounts: map[string]*Account{ + "testuser": { + Login: "testuser", + Name: "Testy McTest", + Password: "password", + Access: &[]byte{1}, + }, + }, + }, + }, + t: NewTransaction( + tranDeleteUser, &[]byte{0, 1}, + NewField(fieldUserLogin, negateString([]byte("testuser"))), + ), + }, + wantRes: []Transaction{ + { + Flags: 0x00, + IsReply: 0x01, + Type: []byte{0x1, 0x5f}, + ID: []byte{0x9a, 0xcb, 0x04, 0x42}, + ErrorCode: []byte{0, 0, 0, 0}, + Fields: []Field(nil), + }, + }, + wantErr: assert.NoError, + }, + { + name: "when user does not have required permission", + setup: func() {}, + args: args{ + cc: &ClientConn{ + Account: &Account{ + Access: func() *[]byte { + var bits accessBitmap + access := bits[:] + return &access + }(), + }, + Server: &Server{ + Accounts: map[string]*Account{}, + }, + }, + t: NewTransaction( + tranDeleteUser, &[]byte{0, 1}, + NewField(fieldUserLogin, negateString([]byte("testuser"))), + ), + }, + wantRes: []Transaction{ + { + Flags: 0x00, + IsReply: 0x01, + Type: []byte{0, 0x00}, + ID: []byte{0x9a, 0xcb, 0x04, 0x42}, + ErrorCode: []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) { + tt.setup() + 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 + } + + tranAssertEqual(t, tt.wantRes, gotRes) + }) + } +} + +func TestHandleGetMsgs(t *testing.T) { + type args struct { + cc *ClientConn + t *Transaction + } + tests := []struct { + name string + args args + wantRes []Transaction + wantErr assert.ErrorAssertionFunc + }{ + { + name: "returns news data", + args: args{ + cc: &ClientConn{ + Account: &Account{ + Access: func() *[]byte { + var bits accessBitmap + bits.Set(accessNewsReadArt) + access := bits[:] + return &access + }(), + }, + Server: &Server{ + FlatNews: []byte("TEST"), + }, + }, + t: NewTransaction( + tranGetMsgs, &[]byte{0, 1}, + ), + }, + wantRes: []Transaction{ + { + Flags: 0x00, + IsReply: 0x01, + Type: []byte{0, 0x65}, + ID: []byte{0x9a, 0xcb, 0x04, 0x42}, + ErrorCode: []byte{0, 0, 0, 0}, + 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() *[]byte { + var bits accessBitmap + access := bits[:] + return &access + }(), + }, + Server: &Server{ + Accounts: map[string]*Account{}, + }, + }, + t: NewTransaction( + tranGetMsgs, &[]byte{0, 1}, + ), + }, + wantRes: []Transaction{ + { + Flags: 0x00, + IsReply: 0x01, + Type: []byte{0, 0x00}, + ID: []byte{0x9a, 0xcb, 0x04, 0x42}, + ErrorCode: []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 + } + + tranAssertEqual(t, tt.wantRes, gotRes) + }) + } +} + +func TestHandleNewUser(t *testing.T) { + type args struct { + cc *ClientConn + 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() *[]byte { + var bits accessBitmap + access := bits[:] + return &access + }(), + }, + Server: &Server{ + Accounts: map[string]*Account{}, + }, + }, + t: NewTransaction( + tranNewUser, &[]byte{0, 1}, + ), + }, + wantRes: []Transaction{ + { + Flags: 0x00, + IsReply: 0x01, + Type: []byte{0, 0x00}, + ID: []byte{0x9a, 0xcb, 0x04, 0x42}, + ErrorCode: []byte{0, 0, 0, 1}, + Fields: []Field{ + NewField(fieldError, []byte("You are not allowed to create new accounts.")), + }, + }, + }, + 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 + } + + tranAssertEqual(t, tt.wantRes, gotRes) + }) + } +} + +func TestHandleListUsers(t *testing.T) { + type args struct { + cc *ClientConn + 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() *[]byte { + var bits accessBitmap + access := bits[:] + return &access + }(), + }, + Server: &Server{ + Accounts: map[string]*Account{}, + }, + }, + t: NewTransaction( + tranNewUser, &[]byte{0, 1}, + ), + }, + wantRes: []Transaction{ + { + Flags: 0x00, + IsReply: 0x01, + Type: []byte{0, 0x00}, + ID: []byte{0x9a, 0xcb, 0x04, 0x42}, + ErrorCode: []byte{0, 0, 0, 1}, + Fields: []Field{ + NewField(fieldError, []byte("You are not allowed to view accounts.")), + }, + }, + }, + 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 + } + + tranAssertEqual(t, tt.wantRes, gotRes) + }) + } +} + +func TestHandleDownloadFile(t *testing.T) { + type args struct { + cc *ClientConn + 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() *[]byte { + var bits accessBitmap + access := bits[:] + return &access + }(), + }, + Server: &Server{}, + }, + t: NewTransaction(tranDownloadFile, &[]byte{0, 1}), + }, + wantRes: []Transaction{ + { + Flags: 0x00, + IsReply: 0x01, + Type: []byte{0, 0x00}, + ID: []byte{0x9a, 0xcb, 0x04, 0x42}, + ErrorCode: []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: make(map[int][]*FileTransfer), + Account: &Account{ + Access: func() *[]byte { + var bits accessBitmap + bits.Set(accessDownloadFile) + access := bits[:] + return &access + }(), + }, + Server: &Server{ + FileTransfers: make(map[uint32]*FileTransfer), + Config: &Config{ + FileRoot: func() string { path, _ := os.Getwd(); return path + "/test/config/Files" }(), + }, + Accounts: map[string]*Account{}, + }, + }, + t: NewTransaction( + accessDownloadFile, + &[]byte{0, 1}, + NewField(fieldFileName, []byte("testfile.txt")), + NewField(fieldFilePath, []byte{0x0, 0x00}), + ), + }, + wantRes: []Transaction{ + { + Flags: 0x00, + IsReply: 0x01, + Type: []byte{0, 0x2}, + ID: []byte{0x9a, 0xcb, 0x04, 0x42}, + ErrorCode: []byte{0, 0, 0, 0}, + Fields: []Field{ + NewField(fieldRefNum, []byte{0x52, 0xfd, 0xfc, 0x07}), + NewField(fieldWaitingCount, []byte{0x00, 0x00}), + NewField(fieldTransferSize, []byte{0x00, 0x00, 0x00, 0xa5}), + NewField(fieldFileSize, []byte{0x00, 0x00, 0x00, 0x17}), + }, + }, + }, + wantErr: assert.NoError, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + // reset the rand seed so that the random fieldRefNum will be deterministic + rand.Seed(1) + + 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 + } + + tranAssertEqual(t, tt.wantRes, gotRes) + }) + } +} + +func TestHandleUpdateUser(t *testing.T) { + type args struct { + cc *ClientConn + t *Transaction + } + tests := []struct { + name string + args args + wantRes []Transaction + wantErr assert.ErrorAssertionFunc + }{ + { + name: "when action is create user without required permission", + args: args{ + cc: &ClientConn{ + Server: &Server{ + Logger: NewTestLogger(), + }, + Account: &Account{ + Access: func() *[]byte { + var bits accessBitmap + access := bits[:] + return &access + }(), + }, + }, + t: NewTransaction( + tranUpdateUser, + &[]byte{0, 0}, + NewField(fieldData, []byte{ + 0x00, 0x04, // field count + + 0x00, 0x69, // fieldUserLogin = 105 + 0x00, 0x03, + 0x9d, 0x9d, 0x9d, + + 0x00, 0x6a, // fieldUserPassword = 106 + 0x00, 0x03, + 0x9c, 0x9c, 0x9c, + + 0x00, 0x66, // fieldUserName = 102 + 0x00, 0x03, + 0x61, 0x61, 0x61, + + 0x00, 0x6e, // fieldUserAccess = 110 + 0x00, 0x08, + 0x60, 0x70, 0x0c, 0x20, 0x03, 0x80, 0x00, 0x00, + }), + ), + }, + wantRes: []Transaction{ + { + Flags: 0x00, + IsReply: 0x01, + Type: []byte{0, 0x00}, + ID: []byte{0x9a, 0xcb, 0x04, 0x42}, + ErrorCode: []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", + args: args{ + cc: &ClientConn{ + Server: &Server{ + Logger: NewTestLogger(), + Accounts: map[string]*Account{ + "bbb": {}, + }, + }, + Account: &Account{ + Access: func() *[]byte { + var bits accessBitmap + access := bits[:] + return &access + }(), + }, + }, + t: NewTransaction( + tranUpdateUser, + &[]byte{0, 0}, + NewField(fieldData, []byte{ + 0x00, 0x04, // field count + + 0x00, 0x69, // fieldUserLogin = 105 + 0x00, 0x03, + 0x9d, 0x9d, 0x9d, + + 0x00, 0x6a, // fieldUserPassword = 106 + 0x00, 0x03, + 0x9c, 0x9c, 0x9c, + + 0x00, 0x66, // fieldUserName = 102 + 0x00, 0x03, + 0x61, 0x61, 0x61, + + 0x00, 0x6e, // fieldUserAccess = 110 + 0x00, 0x08, + 0x60, 0x70, 0x0c, 0x20, 0x03, 0x80, 0x00, 0x00, + }), + ), + }, + wantRes: []Transaction{ + { + Flags: 0x00, + IsReply: 0x01, + Type: []byte{0, 0x00}, + ID: []byte{0x9a, 0xcb, 0x04, 0x42}, + ErrorCode: []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{ + Server: &Server{ + Logger: NewTestLogger(), + Accounts: map[string]*Account{ + "bbb": {}, + }, + }, + Account: &Account{ + Access: func() *[]byte { + var bits accessBitmap + access := bits[:] + return &access + }(), + }, + }, + t: NewTransaction( + tranUpdateUser, + &[]byte{0, 0}, + NewField(fieldData, []byte{ + 0x00, 0x01, + 0x00, 0x65, + 0x00, 0x03, + 0x88, 0x9e, 0x8b, + }), + ), + }, + wantRes: []Transaction{ + { + Flags: 0x00, + IsReply: 0x01, + Type: []byte{0, 0x00}, + ID: []byte{0x9a, 0xcb, 0x04, 0x42}, + ErrorCode: []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 + } + + tranAssertEqual(t, tt.wantRes, gotRes) + }) + } +}