[rbdr/mobius] / hotline / transaction_handlers_test.go

package hotline

import (
	"github.com/stretchr/testify/assert"
	"io/fs"
	"math/rand"
	"os"
	"reflect"
	"testing"
)

func TestHandleSetChatSubject(t *testing.T) {
	type args struct {
		cc *ClientConn
		t  *Transaction
	}
	tests := []struct {
		name    string
		args    args
		want    []Transaction
		wantErr bool
	}{
		{
			name: "sends chat subject to private chat members",
			args: args{
				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: &[]byte{255, 255, 255, 255, 255, 255, 255, 255},
										},
										ID: &[]byte{0, 1},
									},
									uint16(2): {
										Account: &Account{
											Access: &[]byte{255, 255, 255, 255, 255, 255, 255, 255},
										},
										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{255, 255, 255, 255, 255, 255, 255, 255},
								},
								ID: &[]byte{0, 2},
							},
						},
					},
				},
				t: &Transaction{
					Flags:     0x00,
					IsReply:   0x00,
					Type:      []byte{0, 0x6a},
					ID:        []byte{0, 0, 0, 1},
					ErrorCode: []byte{0, 0, 0, 0},
					Fields: []Field{
						NewField(fieldChatID, []byte{0, 0, 0, 1}),
						NewField(fieldChatSubject, []byte("Test Subject")),
					},
				},
			},
			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},
					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},
					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) {
				t.Errorf("HandleSetChatSubject() got = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestHandleLeaveChat(t *testing.T) {
	type args struct {
		cc *ClientConn
		t  *Transaction
	}
	tests := []struct {
		name    string
		args    args
		want    []Transaction
		wantErr bool
	}{
		{
			name: "returns expected transactions",
			args: args{
				cc: &ClientConn{
					ID: &[]byte{0, 2},
					Server: &Server{
						PrivateChats: map[uint32]*PrivateChat{
							uint32(1): {
								ClientConn: 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{255, 255, 255, 255, 255, 255, 255, 255},
										},
										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{255, 255, 255, 255, 255, 255, 255, 255},
								},
								ID: &[]byte{0, 2},
							},
						},
					},
				},
				t: NewTransaction(tranDeleteUser, nil, 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},
					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) {
				t.Errorf("HandleLeaveChat() got = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestHandleGetUserNameList(t *testing.T) {
	type args struct {
		cc *ClientConn
		t  *Transaction
	}
	tests := []struct {
		name    string
		args    args
		want    []Transaction
		wantErr bool
	}{
		{
			name: "replies with userlist transaction",
			args: args{
				cc: &ClientConn{

					ID: &[]byte{1, 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},
							},
						},
					},
				},
				t: &Transaction{
					ID:   []byte{0, 0, 0, 1},
					Type: []byte{0, 1},
				},
			},
			want: []Transaction{
				{
					clientID:  &[]byte{1, 1},
					Flags:     0x00,
					IsReply:   0x01,
					Type:      []byte{0, 1},
					ID:        []byte{0, 0, 0, 1},
					ErrorCode: []byte{0, 0, 0, 0},
					Fields: []Field{
						NewField(
							fieldUsernameWithInfo,
							[]byte{00, 01, 00, 02, 00, 03, 00, 02, 00, 04},
						),
					},
				},
			},
			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
			}
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("HandleGetUserNameList() got = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestHandleChatSend(t *testing.T) {
	type args struct {
		cc *ClientConn
		t  *Transaction
	}
	tests := []struct {
		name    string
		args    args
		want    []Transaction
		wantErr bool
	}{
		{
			name: "sends chat msg transaction to all clients",
			args: args{
				cc: &ClientConn{
					UserName: []byte{0x00, 0x01},
					Server: &Server{
						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{255, 255, 255, 255, 255, 255, 255, 255},
								},
								ID: &[]byte{0, 2},
							},
						},
					},
				},
				t: &Transaction{
					Fields: []Field{
						NewField(fieldData, []byte("hai")),
					},
				},
			},
			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},
					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},
					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: "sends chat msg as emote if fieldChatOptions is set",
			args: args{
				cc: &ClientConn{
					UserName: []byte("Testy McTest"),
					Server: &Server{
						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{255, 255, 255, 255, 255, 255, 255, 255},
								},
								ID: &[]byte{0, 2},
							},
						},
					},
				},
				t: &Transaction{
					Fields: []Field{
						NewField(fieldData, []byte("performed action")),
						NewField(fieldChatOptions, []byte{0x00, 0x01}),
					},
				},
			},
			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},
					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}, // Random ID from rand.Seed(1)
					ErrorCode: []byte{0, 0, 0, 0},
					Fields: []Field{
						NewField(fieldData, []byte("\r*** Testy McTest performed action")),
					},
				},
			},
			wantErr: false,
		},
		{
			name: "only sends chat msg to clients with accessReadChat permission",
			args: args{
				cc: &ClientConn{
					UserName: []byte{0x00, 0x01},
					Server: &Server{
						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},
							},
						},
					},
				},
				t: &Transaction{
					Fields: []Field{
						NewField(fieldData, []byte("hai")),
					},
				},
			},
			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},
					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,
		},
	}
	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)

			if (err != nil) != tt.wantErr {
				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)
			}
		})
	}
}

func TestHandleGetFileInfo(t *testing.T) {
	rand.Seed(1) // reset seed between tests to make transaction IDs predictable

	type args struct {
		cc *ClientConn
		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},
					Server: &Server{
						Config: &Config{
							FileRoot: func() string {
								path, _ := os.Getwd()
								return path + "/test/config/Files"
							}(),
						},
					},
				},
				t: NewTransaction(
					tranGetFileInfo, nil,
					NewField(fieldFileName, []byte("testfile.txt")),
					NewField(fieldFilePath, []byte{0x00, 0x00}),
				),
			},
			wantRes: []Transaction{
				{
					clientID:  &[]byte{0, 1},
					Flags:     0x00,
					IsReply:   0x01,
					Type:      []byte{0, 0xce},
					ID:        []byte{0x9a, 0xcb, 0x04, 0x42}, // Random ID from rand.Seed(1)
					ErrorCode: []byte{0, 0, 0, 0},
					Fields: []Field{
						NewField(fieldFileName, []byte("testfile.txt")),
						NewField(fieldFileTypeString, []byte("TEXT")),
						NewField(fieldFileCreatorString, []byte("ttxt")),
						NewField(fieldFileComment, []byte("TODO")),
						NewField(fieldFileType, []byte("TEXT")),
						NewField(fieldFileCreateDate, make([]byte, 8)),
						NewField(fieldFileModifyDate, make([]byte, 8)),
						NewField(fieldFileSize, []byte{0x0, 0x0, 0x0, 0x17}),
					},
				},
			},
			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
			}

			// 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[5].Data = make([]byte, 8)
			gotRes[0].Fields[6].Data = make([]byte, 8)
			if !assert.Equal(t, tt.wantRes, gotRes) {
				t.Errorf("HandleGetFileInfo() gotRes = %v, want %v", gotRes, tt.wantRes)
			}
		})
	}
}

func TestHandleNewFolder(t *testing.T) {
	type args struct {
		cc *ClientConn
		t  *Transaction
	}
	tests := []struct {
		setup   func()
		name    string
		args    args
		wantRes []Transaction
		wantErr bool
	}{
		{
			name: "when path is nested",
			args: args{
				cc: &ClientConn{
					ID: &[]byte{0, 1},
					Server: &Server{
						Config: &Config{
							FileRoot: "/Files/",
						},
					},
				},
				t: NewTransaction(
					tranNewFolder, &[]byte{0, 1},
					NewField(fieldFileName, []byte("testFolder")),
					NewField(fieldFilePath, []byte{
						0x00, 0x01,
						0x00, 0x00,
						0x03,
						0x61, 0x61, 0x61,
					}),
				),
			},
			setup: func() {
				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
			},
			wantRes: []Transaction{
				{
					clientID:  &[]byte{0, 1},
					Flags:     0x00,
					IsReply:   0x01,
					Type:      []byte{0, 0xcd},
					ID:        []byte{0x9a, 0xcb, 0x04, 0x42}, // Random ID from rand.Seed(1)
					ErrorCode: []byte{0, 0, 0, 0},
				},
			},
			wantErr: false,
		},
		{
			name: "when path is not nested",
			args: args{
				cc: &ClientConn{
					ID: &[]byte{0, 1},
					Server: &Server{
						Config: &Config{
							FileRoot: "/Files",
						},
					},
				},
				t: NewTransaction(
					tranNewFolder, &[]byte{0, 1},
					NewField(fieldFileName, []byte("testFolder")),
				),
			},
			setup: func() {
				mfs := MockFileStore{}
				mfs.On("Mkdir", "/Files/testFolder", fs.FileMode(0777)).Return(nil)
				mfs.On("Stat", "/Files/testFolder").Return(nil, os.ErrNotExist)
				FS = mfs
			},
			wantRes: []Transaction{
				{
					clientID:  &[]byte{0, 1},
					Flags:     0x00,
					IsReply:   0x01,
					Type:      []byte{0, 0xcd},
					ID:        []byte{0x9a, 0xcb, 0x04, 0x42}, // Random ID from rand.Seed(1)
					ErrorCode: []byte{0, 0, 0, 0},
				},
			},
			wantErr: false,
		},
		{
			name: "when UnmarshalBinary returns an err",
			args: args{
				cc: &ClientConn{
					ID: &[]byte{0, 1},
					Server: &Server{
						Config: &Config{
							FileRoot: "/Files/",
						},
					},
				},
				t: NewTransaction(
					tranNewFolder, &[]byte{0, 1},
					NewField(fieldFileName, []byte("testFolder")),
					NewField(fieldFilePath, []byte{
						0x00,
					}),
				),
			},
			setup: func() {
				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
			},
			wantRes: []Transaction{},
			wantErr: true,
		},
		{
			name: "fieldFileName does not allow directory traversal",
			args: args{
				cc: &ClientConn{
					ID: &[]byte{0, 1},
					Server: &Server{
						Config: &Config{
							FileRoot: "/Files/",
						},
					},
				},
				t: NewTransaction(
					tranNewFolder, &[]byte{0, 1},
					NewField(fieldFileName, []byte("../../testFolder")),
				),
			},
			setup: func() {
				mfs := MockFileStore{}
				mfs.On("Mkdir", "/Files/testFolder", fs.FileMode(0777)).Return(nil)
				mfs.On("Stat", "/Files/testFolder").Return(nil, os.ErrNotExist)
				FS = mfs
			},
			wantRes: []Transaction{
				{
					clientID:  &[]byte{0, 1},
					Flags:     0x00,
					IsReply:   0x01,
					Type:      []byte{0, 0xcd},
					ID:        []byte{0x9a, 0xcb, 0x04, 0x42}, // Random ID from rand.Seed(1)
					ErrorCode: []byte{0, 0, 0, 0},
				},
			}, wantErr: false,
		},
		{
			name: "fieldFilePath does not allow directory traversal",
			args: args{
				cc: &ClientConn{
					ID: &[]byte{0, 1},
					Server: &Server{
						Config: &Config{
							FileRoot: "/Files/",
						},
					},
				},
				t: NewTransaction(
					tranNewFolder, &[]byte{0, 1},
					NewField(fieldFileName, []byte("testFolder")),
					NewField(fieldFilePath, []byte{
						0x00, 0x02,
						0x00, 0x00,
						0x03,
						0x2e, 0x2e, 0x2f,
						0x00, 0x00,
						0x03,
						0x66, 0x6f, 0x6f,
					}),
				),
			},
			setup: func() {
				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
			},
			wantRes: []Transaction{
				{
					clientID:  &[]byte{0, 1},
					Flags:     0x00,
					IsReply:   0x01,
					Type:      []byte{0, 0xcd},
					ID:        []byte{0x9a, 0xcb, 0x04, 0x42}, // Random ID from rand.Seed(1)
					ErrorCode: []byte{0, 0, 0, 0},
				},
			}, wantErr: false,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			tt.setup()

			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
			}
			if !tranAssertEqual(t, tt.wantRes, gotRes) {
				t.Errorf("HandleNewFolder() gotRes = %v, want %v", gotRes, tt.wantRes)
			}
		})
	}
}

func TestHandleUploadFile(t *testing.T) {
	type args struct {
		cc *ClientConn
		t  *Transaction
	}
	tests := []struct {
		name    string
		args    args
		wantRes []Transaction
		wantErr bool
	}{
		{
			name: "when request is valid",
			args: args{
				cc: &ClientConn{
					Server: &Server{
						FileTransfers: map[uint32]*FileTransfer{},
					},
					Account: &Account{
						Access: func() *[]byte {
							var bits accessBitmap
							bits.Set(accessUploadFile)
							access := bits[:]
							return &access
						}(),
					},
				},
				t: NewTransaction(
					tranUploadFile, &[]byte{0, 1},
					NewField(fieldFileName, []byte("testFile")),
					NewField(fieldFilePath, []byte{
						0x00, 0x01,
						0x00, 0x00,
						0x03,
						0x2e, 0x2e, 0x2f,
					}),
				),
			},
			wantRes: []Transaction{
				{
					Flags:     0x00,
					IsReply:   0x01,
					Type:      []byte{0, 0xcb},
					ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
					ErrorCode: []byte{0, 0, 0, 0},
					Fields: []Field{
						NewField(fieldRefNum, []byte{0x52, 0xfd, 0xfc, 0x07}), // rand.Seed(1)
					},
				},
			},
			wantErr: false,
		},
		{
			name: "when user does not have required access",
			args: args{
				cc: &ClientConn{
					Account: &Account{
						Access: func() *[]byte {
							var bits accessBitmap
							access := bits[:]
							return &access
						}(),
					},
					Server: &Server{
						FileTransfers: map[uint32]*FileTransfer{},
					},
				},
				t: NewTransaction(
					tranUploadFile, &[]byte{0, 1},
					NewField(fieldFileName, []byte("testFile")),
					NewField(fieldFilePath, []byte{
						0x00, 0x01,
						0x00, 0x00,
						0x03,
						0x2e, 0x2e, 0x2f,
					}),
				),
			},
			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 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
			}
			if !tranAssertEqual(t, tt.wantRes, gotRes) {
				t.Errorf("HandleUploadFile() gotRes = %v, want %v", gotRes, tt.wantRes)
			}
		})
	}
}
Commit	Line	Data
6988a057 JH	1	package hotline
	2
	3	import (
	4	"github.com/stretchr/testify/assert"
00d1ef67	5	"io/fs"
6988a057	6	"math/rand"
00d1ef67	7	"os"
6988a057 JH	8	"reflect"
	9	"testing"
	10	)
	11
	12	func TestHandleSetChatSubject(t *testing.T) {
	13	type args struct {
	14	cc *ClientConn
	15	t *Transaction
	16	}
	17	tests := []struct {
	18	name string
	19	args args
	20	want []Transaction
	21	wantErr bool
	22	}{
	23	{
	24	name: "sends chat subject to private chat members",
	25	args: args{
	26	cc: &ClientConn{
72dd37f1	27	UserName: []byte{0x00, 0x01},
6988a057 JH	28	Server: &Server{
	29	PrivateChats: map[uint32]*PrivateChat{
	30	uint32(1): {
	31	Subject: "unset",
	32	ClientConn: map[uint16]*ClientConn{
	33	uint16(1): {
	34	Account: &Account{
	35	Access: &[]byte{255, 255, 255, 255, 255, 255, 255, 255},
	36	},
	37	ID: &[]byte{0, 1},
	38	},
	39	uint16(2): {
	40	Account: &Account{
	41	Access: &[]byte{255, 255, 255, 255, 255, 255, 255, 255},
	42	},
	43	ID: &[]byte{0, 2},
	44	},
	45	},
	46	},
	47	},
	48	Clients: map[uint16]*ClientConn{
	49	uint16(1): {
	50	Account: &Account{
	51	Access: &[]byte{255, 255, 255, 255, 255, 255, 255, 255},
	52	},
	53	ID: &[]byte{0, 1},
	54	},
	55	uint16(2): {
	56	Account: &Account{
	57	Access: &[]byte{255, 255, 255, 255, 255, 255, 255, 255},
	58	},
	59	ID: &[]byte{0, 2},
	60	},
	61	},
	62	},
	63	},
	64	t: &Transaction{
	65	Flags: 0x00,
	66	IsReply: 0x00,
	67	Type: []byte{0, 0x6a},
	68	ID: []byte{0, 0, 0, 1},
	69	ErrorCode: []byte{0, 0, 0, 0},
	70	Fields: []Field{
	71	NewField(fieldChatID, []byte{0, 0, 0, 1}),
	72	NewField(fieldChatSubject, []byte("Test Subject")),
	73	},
	74	},
	75	},
	76	want: []Transaction{
	77	{
	78	clientID: &[]byte{0, 1},
	79	Flags: 0x00,
	80	IsReply: 0x00,
	81	Type: []byte{0, 0x77},
	82	ID: []byte{0x9a, 0xcb, 0x04, 0x42}, // Random ID from rand.Seed(1)
	83	ErrorCode: []byte{0, 0, 0, 0},
	84	Fields: []Field{
	85	NewField(fieldChatID, []byte{0, 0, 0, 1}),
	86	NewField(fieldChatSubject, []byte("Test Subject")),
	87	},
	88	},
	89	{
	90	clientID: &[]byte{0, 2},
	91	Flags: 0x00,
92	IsReply: 0x00,
93	Type: []byte{0, 0x77},
94	ID: []byte{0xf0, 0xc5, 0x34, 0x1e}, // Random ID from rand.Seed(1)
95	ErrorCode: []byte{0, 0, 0, 0},
96	Fields: []Field{
97	NewField(fieldChatID, []byte{0, 0, 0, 1}),
98	NewField(fieldChatSubject, []byte("Test Subject")),
99	},
100	},
101	},
102	wantErr: false,
103	},
104	}
105	for _, tt := range tests {
106	rand.Seed(1) // reset seed between tests to make transaction IDs predictable
107
108	t.Run(tt.name, func(t *testing.T) {
109	got, err := HandleSetChatSubject(tt.args.cc, tt.args.t)
110	if (err != nil) != tt.wantErr {
111	t.Errorf("HandleSetChatSubject() error = %v, wantErr %v", err, tt.wantErr)
112	return
113	}
114	if !assert.Equal(t, tt.want, got) {
115	t.Errorf("HandleSetChatSubject() got = %v, want %v", got, tt.want)
116	}
117	})
118	}
119	}
120
121	func TestHandleLeaveChat(t *testing.T) {
122	type args struct {
123	cc *ClientConn
124	t *Transaction
125	}
126	tests := []struct {
127	name string
128	args args
129	want []Transaction
130	wantErr bool
131	}{
132	{
133	name: "returns expected transactions",
134	args: args{
135	cc: &ClientConn{
136	ID: &[]byte{0, 2},
137	Server: &Server{
138	PrivateChats: map[uint32]*PrivateChat{
139	uint32(1): {
140	ClientConn: map[uint16]*ClientConn{
141	uint16(1): {
142	Account: &Account{
143	Access: &[]byte{255, 255, 255, 255, 255, 255, 255, 255},
144	},
145	ID: &[]byte{0, 1},
146	},
147	uint16(2): {
148	Account: &Account{
149	Access: &[]byte{255, 255, 255, 255, 255, 255, 255, 255},
150	},
151	ID: &[]byte{0, 2},
152	},
153	},
154	},
155	},
156	Clients: map[uint16]*ClientConn{
157	uint16(1): {
158	Account: &Account{
159	Access: &[]byte{255, 255, 255, 255, 255, 255, 255, 255},
160	},
161	ID: &[]byte{0, 1},
162	},
163	uint16(2): {
164	Account: &Account{
165	Access: &[]byte{255, 255, 255, 255, 255, 255, 255, 255},
166	},
167	ID: &[]byte{0, 2},
168	},
169	},
170	},
171	},
5c34f875	172	t: NewTransaction(tranDeleteUser, nil, NewField(fieldChatID, []byte{0, 0, 0, 1})),
6988a057 JH	173	},
	174	want: []Transaction{
	175	{
	176	clientID: &[]byte{0, 1},
	177	Flags: 0x00,
	178	IsReply: 0x00,
	179	Type: []byte{0, 0x76},
	180	ID: []byte{0x9a, 0xcb, 0x04, 0x42}, // Random ID from rand.Seed(1)
	181	ErrorCode: []byte{0, 0, 0, 0},
	182	Fields: []Field{
	183	NewField(fieldChatID, []byte{0, 0, 0, 1}),
	184	NewField(fieldUserID, []byte{0, 2}),
	185	},
	186	},
	187	},
	188	wantErr: false,
	189	},
	190	}
	191	for _, tt := range tests {
	192	rand.Seed(1)
	193	t.Run(tt.name, func(t *testing.T) {
	194	got, err := HandleLeaveChat(tt.args.cc, tt.args.t)
	195	if (err != nil) != tt.wantErr {
	196	t.Errorf("HandleLeaveChat() error = %v, wantErr %v", err, tt.wantErr)
	197	return
	198	}
	199	if !assert.Equal(t, tt.want, got) {
	200	t.Errorf("HandleLeaveChat() got = %v, want %v", got, tt.want)
	201	}
	202	})
	203	}
	204	}
	205
6988a057 JH	206	func TestHandleGetUserNameList(t *testing.T) {
	207	type args struct {
	208	cc *ClientConn
	209	t *Transaction
	210	}
	211	tests := []struct {
	212	name string
	213	args args
	214	want []Transaction
	215	wantErr bool
	216	}{
	217	{
	218	name: "replies with userlist transaction",
	219	args: args{
	220	cc: &ClientConn{
	221
	222	ID: &[]byte{1, 1},
	223	Server: &Server{
	224	Clients: map[uint16]*ClientConn{
	225	uint16(1): {
	226	ID: &[]byte{0, 1},
	227	Icon: &[]byte{0, 2},
	228	Flags: &[]byte{0, 3},
72dd37f1	229	UserName: []byte{0, 4},
6988a057 JH	230	},
	231	},
	232	},
	233	},
	234	t: &Transaction{
	235	ID: []byte{0, 0, 0, 1},
	236	Type: []byte{0, 1},
	237	},
	238	},
	239	want: []Transaction{
	240	{
	241	clientID: &[]byte{1, 1},
	242	Flags: 0x00,
	243	IsReply: 0x01,
	244	Type: []byte{0, 1},
	245	ID: []byte{0, 0, 0, 1},
	246	ErrorCode: []byte{0, 0, 0, 0},
	247	Fields: []Field{
	248	NewField(
	249	fieldUsernameWithInfo,
	250	[]byte{00, 01, 00, 02, 00, 03, 00, 02, 00, 04},
	251	),
	252	},
	253	},
	254	},
	255	wantErr: false,
	256	},
	257	}
	258	for _, tt := range tests {
	259	t.Run(tt.name, func(t *testing.T) {
	260	got, err := HandleGetUserNameList(tt.args.cc, tt.args.t)
	261	if (err != nil) != tt.wantErr {
	262	t.Errorf("HandleGetUserNameList() error = %v, wantErr %v", err, tt.wantErr)
	263	return
	264	}
	265	if !reflect.DeepEqual(got, tt.want) {
	266	t.Errorf("HandleGetUserNameList() got = %v, want %v", got, tt.want)
	267	}
	268	})
	269	}
	270	}
	271
	272	func TestHandleChatSend(t *testing.T) {
	273	type args struct {
	274	cc *ClientConn
	275	t *Transaction
	276	}
	277	tests := []struct {
	278	name string
	279	args args
	280	want []Transaction
	281	wantErr bool
	282	}{
	283	{
	284	name: "sends chat msg transaction to all clients",
	285	args: args{
	286	cc: &ClientConn{
72dd37f1	287	UserName: []byte{0x00, 0x01},
6988a057 JH	288	Server: &Server{
	289	Clients: map[uint16]*ClientConn{
	290	uint16(1): {
	291	Account: &Account{
	292	Access: &[]byte{255, 255, 255, 255, 255, 255, 255, 255},
	293	},
	294	ID: &[]byte{0, 1},
	295	},
	296	uint16(2): {
	297	Account: &Account{
	298	Access: &[]byte{255, 255, 255, 255, 255, 255, 255, 255},
	299	},
	300	ID: &[]byte{0, 2},
	301	},
	302	},
	303	},
	304	},
	305	t: &Transaction{
	306	Fields: []Field{
	307	NewField(fieldData, []byte("hai")),
	308	},
	309	},
	310	},
	311	want: []Transaction{
	312	{
	313	clientID: &[]byte{0, 1},
	314	Flags: 0x00,
	315	IsReply: 0x00,
	316	Type: []byte{0, 0x6a},
	317	ID: []byte{0x9a, 0xcb, 0x04, 0x42}, // Random ID from rand.Seed(1)
	318	ErrorCode: []byte{0, 0, 0, 0},
	319	Fields: []Field{
	320	NewField(fieldData, []byte{0x0d, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x01, 0x3a, 0x20, 0x20, 0x68, 0x61, 0x69}),
	321	},
	322	},
	323	{
	324	clientID: &[]byte{0, 2},
	325	Flags: 0x00,
	326	IsReply: 0x00,
	327	Type: []byte{0, 0x6a},
	328	ID: []byte{0xf0, 0xc5, 0x34, 0x1e}, // Random ID from rand.Seed(1)
	329	ErrorCode: []byte{0, 0, 0, 0},
	330	Fields: []Field{
	331	NewField(fieldData, []byte{0x0d, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x01, 0x3a, 0x20, 0x20, 0x68, 0x61, 0x69}),
	332	},
	333	},
	334	},
	335	wantErr: false,
	336	},
72dd37f1 JH	337	{
	338	name: "sends chat msg as emote if fieldChatOptions is set",
	339	args: args{
	340	cc: &ClientConn{
	341	UserName: []byte("Testy McTest"),
	342	Server: &Server{
	343	Clients: map[uint16]*ClientConn{
	344	uint16(1): {
	345	Account: &Account{
	346	Access: &[]byte{255, 255, 255, 255, 255, 255, 255, 255},
	347	},
	348	ID: &[]byte{0, 1},
	349	},
	350	uint16(2): {
	351	Account: &Account{
	352	Access: &[]byte{255, 255, 255, 255, 255, 255, 255, 255},
	353	},
	354	ID: &[]byte{0, 2},
	355	},
	356	},
	357	},
	358	},
	359	t: &Transaction{
	360	Fields: []Field{
	361	NewField(fieldData, []byte("performed action")),
	362	NewField(fieldChatOptions, []byte{0x00, 0x01}),
	363	},
	364	},
	365	},
	366	want: []Transaction{
	367	{
	368	clientID: &[]byte{0, 1},
	369	Flags: 0x00,
	370	IsReply: 0x00,
	371	Type: []byte{0, 0x6a},
	372	ID: []byte{0x9a, 0xcb, 0x04, 0x42}, // Random ID from rand.Seed(1)
	373	ErrorCode: []byte{0, 0, 0, 0},
	374	Fields: []Field{
	375	NewField(fieldData, []byte("\r*** Testy McTest performed action")),
	376	},
	377	},
	378	{
	379	clientID: &[]byte{0, 2},
	380	Flags: 0x00,
	381	IsReply: 0x00,
	382	Type: []byte{0, 0x6a},
	383	ID: []byte{0xf0, 0xc5, 0x34, 0x1e}, // Random ID from rand.Seed(1)
	384	ErrorCode: []byte{0, 0, 0, 0},
	385	Fields: []Field{
	386	NewField(fieldData, []byte("\r*** Testy McTest performed action")),
	387	},
	388	},
	389	},
	390	wantErr: false,
	391	},
6988a057 JH	392	{
	393	name: "only sends chat msg to clients with accessReadChat permission",
	394	args: args{
	395	cc: &ClientConn{
72dd37f1	396	UserName: []byte{0x00, 0x01},
6988a057 JH	397	Server: &Server{
	398	Clients: map[uint16]*ClientConn{
	399	uint16(1): {
	400	Account: &Account{
	401	Access: &[]byte{255, 255, 255, 255, 255, 255, 255, 255},
	402	},
	403	ID: &[]byte{0, 1},
	404	},
	405	uint16(2): {
	406	Account: &Account{
	407	Access: &[]byte{0, 0, 0, 0, 0, 0, 0, 0},
	408	},
	409	ID: &[]byte{0, 2},
	410	},
	411	},
	412	},
	413	},
	414	t: &Transaction{
	415	Fields: []Field{
	416	NewField(fieldData, []byte("hai")),
	417	},
	418	},
	419	},
	420	want: []Transaction{
	421	{
	422	clientID: &[]byte{0, 1},
	423	Flags: 0x00,
	424	IsReply: 0x00,
	425	Type: []byte{0, 0x6a},
	426	ID: []byte{0x9a, 0xcb, 0x04, 0x42}, // Random ID from rand.Seed(1)
	427	ErrorCode: []byte{0, 0, 0, 0},
	428	Fields: []Field{
	429	NewField(fieldData, []byte{0x0d, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x01, 0x3a, 0x20, 0x20, 0x68, 0x61, 0x69}),
	430	},
	431	},
	432	},
	433	wantErr: false,
	434	},
	435	}
	436	for _, tt := range tests {
	437	rand.Seed(1) // reset seed between tests to make transaction IDs predictable
	438	t.Run(tt.name, func(t *testing.T) {
	439	got, err := HandleChatSend(tt.args.cc, tt.args.t)
	440
	441	if (err != nil) != tt.wantErr {
	442	t.Errorf("HandleChatSend() error = %v, wantErr %v", err, tt.wantErr)
	443	return
	444	}
	445	if !assert.Equal(t, tt.want, got) {
	446	t.Errorf("HandleChatSend() got = %v, want %v", got, tt.want)
	447	}
	448	})
	449	}
	450	}
72dd37f1 JH	451
	452	func TestHandleGetFileInfo(t *testing.T) {
	453	rand.Seed(1) // reset seed between tests to make transaction IDs predictable
	454
	455	type args struct {
	456	cc *ClientConn
	457	t *Transaction
	458	}
	459	tests := []struct {
	460	name string
	461	args args
	462	wantRes []Transaction
	463	wantErr bool
	464	}{
	465	{
	466	name: "returns expected fields when a valid file is requested",
	467	args: args{
	468	cc: &ClientConn{
	469	ID: &[]byte{0x00, 0x01},
	470	Server: &Server{
	471	Config: &Config{
29f329ae JH	472	FileRoot: func() string {
	473	path, _ := os.Getwd()
	474	return path + "/test/config/Files"
	475	}(),
72dd37f1 JH	476	},
	477	},
	478	},
	479	t: NewTransaction(
	480	tranGetFileInfo, nil,
	481	NewField(fieldFileName, []byte("testfile.txt")),
	482	NewField(fieldFilePath, []byte{0x00, 0x00}),
72dd37f1 JH	483	),
	484	},
	485	wantRes: []Transaction{
	486	{
	487	clientID: &[]byte{0, 1},
	488	Flags: 0x00,
	489	IsReply: 0x01,
	490	Type: []byte{0, 0xce},
	491	ID: []byte{0x9a, 0xcb, 0x04, 0x42}, // Random ID from rand.Seed(1)
	492	ErrorCode: []byte{0, 0, 0, 0},
	493	Fields: []Field{
	494	NewField(fieldFileName, []byte("testfile.txt")),
	495	NewField(fieldFileTypeString, []byte("TEXT")),
2728d12b	496	NewField(fieldFileCreatorString, []byte("ttxt")),
72dd37f1 JH	497	NewField(fieldFileComment, []byte("TODO")),
72dd37f1 JH	498	NewField(fieldFileType, []byte("TEXT")),
29f329ae JH	499	NewField(fieldFileCreateDate, make([]byte, 8)),
29f329ae JH	500	NewField(fieldFileModifyDate, make([]byte, 8)),
72dd37f1 JH	501	NewField(fieldFileSize, []byte{0x0, 0x0, 0x0, 0x17}),
	502	},
	503	},
	504	},
	505	wantErr: false,
	506	},
	507	}
	508	for _, tt := range tests {
	509	t.Run(tt.name, func(t *testing.T) {
	510	rand.Seed(1) // reset seed between tests to make transaction IDs predictable
	511
	512	gotRes, err := HandleGetFileInfo(tt.args.cc, tt.args.t)
	513	if (err != nil) != tt.wantErr {
	514	t.Errorf("HandleGetFileInfo() error = %v, wantErr %v", err, tt.wantErr)
	515	return
	516	}
29f329ae JH	517
	518	// Clear the file timestamp fields to work around problems running the tests in multiple timezones
	519	// TODO: revisit how to test this by mocking the stat calls
	520	gotRes[0].Fields[5].Data = make([]byte, 8)
	521	gotRes[0].Fields[6].Data = make([]byte, 8)
00d1ef67	522	if !assert.Equal(t, tt.wantRes, gotRes) {
72dd37f1 JH	523	t.Errorf("HandleGetFileInfo() gotRes = %v, want %v", gotRes, tt.wantRes)
	524	}
	525	})
	526	}
	527	}
00d1ef67 JH	528
	529	func TestHandleNewFolder(t *testing.T) {
	530	type args struct {
	531	cc *ClientConn
	532	t *Transaction
	533	}
	534	tests := []struct {
	535	setup func()
	536	name string
	537	args args
	538	wantRes []Transaction
	539	wantErr bool
	540	}{
	541	{
	542	name: "when path is nested",
	543	args: args{
	544	cc: &ClientConn{
	545	ID: &[]byte{0, 1},
	546	Server: &Server{
	547	Config: &Config{
	548	FileRoot: "/Files/",
	549	},
	550	},
	551	},
	552	t: NewTransaction(
	553	tranNewFolder, &[]byte{0, 1},
	554	NewField(fieldFileName, []byte("testFolder")),
	555	NewField(fieldFilePath, []byte{
	556	0x00, 0x01,
	557	0x00, 0x00,
	558	0x03,
	559	0x61, 0x61, 0x61,
	560	}),
	561	),
	562	},
	563	setup: func() {
	564	mfs := MockFileStore{}
	565	mfs.On("Mkdir", "/Files/aaa/testFolder", fs.FileMode(0777)).Return(nil)
	566	mfs.On("Stat", "/Files/aaa/testFolder").Return(nil, os.ErrNotExist)
	567	FS = mfs
	568	},
	569	wantRes: []Transaction{
	570	{
	571	clientID: &[]byte{0, 1},
	572	Flags: 0x00,
	573	IsReply: 0x01,
	574	Type: []byte{0, 0xcd},
	575	ID: []byte{0x9a, 0xcb, 0x04, 0x42}, // Random ID from rand.Seed(1)
	576	ErrorCode: []byte{0, 0, 0, 0},
	577	},
	578	},
	579	wantErr: false,
	580	},
	581	{
	582	name: "when path is not nested",
	583	args: args{
	584	cc: &ClientConn{
	585	ID: &[]byte{0, 1},
	586	Server: &Server{
	587	Config: &Config{
	588	FileRoot: "/Files",
	589	},
	590	},
	591	},
592	t: NewTransaction(
593	tranNewFolder, &[]byte{0, 1},
594	NewField(fieldFileName, []byte("testFolder")),
595	),
596	},
597	setup: func() {
598	mfs := MockFileStore{}
599	mfs.On("Mkdir", "/Files/testFolder", fs.FileMode(0777)).Return(nil)
600	mfs.On("Stat", "/Files/testFolder").Return(nil, os.ErrNotExist)
601	FS = mfs
602	},
603	wantRes: []Transaction{
604	{
605	clientID: &[]byte{0, 1},
606	Flags: 0x00,
607	IsReply: 0x01,
608	Type: []byte{0, 0xcd},
609	ID: []byte{0x9a, 0xcb, 0x04, 0x42}, // Random ID from rand.Seed(1)
610	ErrorCode: []byte{0, 0, 0, 0},
611	},
612	},
613	wantErr: false,
614	},
615	{
616	name: "when UnmarshalBinary returns an err",
617	args: args{
618	cc: &ClientConn{
619	ID: &[]byte{0, 1},
620	Server: &Server{
621	Config: &Config{
622	FileRoot: "/Files/",
623	},
624	},
625	},
626	t: NewTransaction(
627	tranNewFolder, &[]byte{0, 1},
628	NewField(fieldFileName, []byte("testFolder")),
629	NewField(fieldFilePath, []byte{
630	0x00,
631	}),
632	),
633	},
634	setup: func() {
635	mfs := MockFileStore{}
636	mfs.On("Mkdir", "/Files/aaa/testFolder", fs.FileMode(0777)).Return(nil)
637	mfs.On("Stat", "/Files/aaa/testFolder").Return(nil, os.ErrNotExist)
638	FS = mfs
639	},
640	wantRes: []Transaction{},
641	wantErr: true,
642	},
643	{
644	name: "fieldFileName does not allow directory traversal",
645	args: args{
646	cc: &ClientConn{
647	ID: &[]byte{0, 1},
648	Server: &Server{
649	Config: &Config{
650	FileRoot: "/Files/",
651	},
652	},
653	},
654	t: NewTransaction(
655	tranNewFolder, &[]byte{0, 1},
656	NewField(fieldFileName, []byte("../../testFolder")),
00d1ef67 JH	657	),
	658	},
	659	setup: func() {
	660	mfs := MockFileStore{}
	661	mfs.On("Mkdir", "/Files/testFolder", fs.FileMode(0777)).Return(nil)
	662	mfs.On("Stat", "/Files/testFolder").Return(nil, os.ErrNotExist)
	663	FS = mfs
	664	},
	665	wantRes: []Transaction{
	666	{
	667	clientID: &[]byte{0, 1},
	668	Flags: 0x00,
	669	IsReply: 0x01,
	670	Type: []byte{0, 0xcd},
	671	ID: []byte{0x9a, 0xcb, 0x04, 0x42}, // Random ID from rand.Seed(1)
	672	ErrorCode: []byte{0, 0, 0, 0},
	673	},
92a7e455	674	}, wantErr: false,
00d1ef67 JH	675	},
	676	{
	677	name: "fieldFilePath does not allow directory traversal",
	678	args: args{
	679	cc: &ClientConn{
	680	ID: &[]byte{0, 1},
	681	Server: &Server{
	682	Config: &Config{
	683	FileRoot: "/Files/",
	684	},
	685	},
	686	},
	687	t: NewTransaction(
	688	tranNewFolder, &[]byte{0, 1},
	689	NewField(fieldFileName, []byte("testFolder")),
	690	NewField(fieldFilePath, []byte{
	691	0x00, 0x02,
	692	0x00, 0x00,
	693	0x03,
	694	0x2e, 0x2e, 0x2f,
	695	0x00, 0x00,
	696	0x03,
	697	0x66, 0x6f, 0x6f,
	698	}),
	699	),
	700	},
	701	setup: func() {
	702	mfs := MockFileStore{}
	703	mfs.On("Mkdir", "/Files/foo/testFolder", fs.FileMode(0777)).Return(nil)
	704	mfs.On("Stat", "/Files/foo/testFolder").Return(nil, os.ErrNotExist)
	705	FS = mfs
	706	},
	707	wantRes: []Transaction{
	708	{
	709	clientID: &[]byte{0, 1},
	710	Flags: 0x00,
	711	IsReply: 0x01,
	712	Type: []byte{0, 0xcd},
	713	ID: []byte{0x9a, 0xcb, 0x04, 0x42}, // Random ID from rand.Seed(1)
	714	ErrorCode: []byte{0, 0, 0, 0},
	715	},
92a7e455	716	}, wantErr: false,
00d1ef67 JH	717	},
	718	}
	719	for _, tt := range tests {
	720	t.Run(tt.name, func(t *testing.T) {
	721	tt.setup()
	722
	723	gotRes, err := HandleNewFolder(tt.args.cc, tt.args.t)
	724	if (err != nil) != tt.wantErr {
	725	t.Errorf("HandleNewFolder() error = %v, wantErr %v", err, tt.wantErr)
	726	return
	727	}
	728	if !tranAssertEqual(t, tt.wantRes, gotRes) {
	729	t.Errorf("HandleNewFolder() gotRes = %v, want %v", gotRes, tt.wantRes)
	730	}
	731	})
	732	}
	733	}
	734
92a7e455 JH	735	func TestHandleUploadFile(t *testing.T) {
	736	type args struct {
	737	cc *ClientConn
	738	t *Transaction
	739	}
	740	tests := []struct {
	741	name string
	742	args args
	743	wantRes []Transaction
	744	wantErr bool
	745	}{
	746	{
	747	name: "when request is valid",
	748	args: args{
	749	cc: &ClientConn{
	750	Server: &Server{
	751	FileTransfers: map[uint32]*FileTransfer{},
	752	},
	753	Account: &Account{
	754	Access: func() *[]byte {
	755	var bits accessBitmap
	756	bits.Set(accessUploadFile)
	757	access := bits[:]
	758	return &access
	759	}(),
	760	},
	761	},
	762	t: NewTransaction(
	763	tranUploadFile, &[]byte{0, 1},
	764	NewField(fieldFileName, []byte("testFile")),
	765	NewField(fieldFilePath, []byte{
	766	0x00, 0x01,
	767	0x00, 0x00,
	768	0x03,
	769	0x2e, 0x2e, 0x2f,
	770	}),
	771	),
	772	},
	773	wantRes: []Transaction{
	774	{
	775	Flags: 0x00,
	776	IsReply: 0x01,
	777	Type: []byte{0, 0xcb},
	778	ID: []byte{0x9a, 0xcb, 0x04, 0x42},
	779	ErrorCode: []byte{0, 0, 0, 0},
	780	Fields: []Field{
	781	NewField(fieldRefNum, []byte{0x52, 0xfd, 0xfc, 0x07}), // rand.Seed(1)
	782	},
	783	},
	784	},
	785	wantErr: false,
	786	},
	787	{
	788	name: "when user does not have required access",
	789	args: args{
	790	cc: &ClientConn{
	791	Account: &Account{
	792	Access: func() *[]byte {
	793	var bits accessBitmap
	794	access := bits[:]
	795	return &access
	796	}(),
	797	},
	798	Server: &Server{
799	FileTransfers: map[uint32]*FileTransfer{},
800	},
801	},
802	t: NewTransaction(
803	tranUploadFile, &[]byte{0, 1},
804	NewField(fieldFileName, []byte("testFile")),
805	NewField(fieldFilePath, []byte{
806	0x00, 0x01,
807	0x00, 0x00,
808	0x03,
809	0x2e, 0x2e, 0x2f,
810	}),
811	),
812	},
813	wantRes: []Transaction{
814	{
815	Flags: 0x00,
816	IsReply: 0x01,
817	Type: []byte{0, 0x00},
818	ID: []byte{0x9a, 0xcb, 0x04, 0x42},
819	ErrorCode: []byte{0, 0, 0, 1},
820	Fields: []Field{
821	NewField(fieldError, []byte("You are not allowed to upload files.")), // rand.Seed(1)
822	},
823	},
824	},
825	wantErr: false,
826	},
827	}
828	for _, tt := range tests {
829	t.Run(tt.name, func(t *testing.T) {
830	rand.Seed(1)
831	gotRes, err := HandleUploadFile(tt.args.cc, tt.args.t)
832	if (err != nil) != tt.wantErr {
833	t.Errorf("HandleUploadFile() error = %v, wantErr %v", err, tt.wantErr)
834	return
835	}
836	if !tranAssertEqual(t, tt.wantRes, gotRes) {
837	t.Errorf("HandleUploadFile() gotRes = %v, want %v", gotRes, tt.wantRes)
838	}
839	})
840	}
841	}