"os"
"path/filepath"
"strings"
- "sync"
"testing"
"time"
)
cc: &ClientConn{
UserName: []byte{0x00, 0x01},
Server: &Server{
- 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},
+ 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},
},
- [2]byte{0, 2}: {
- Account: &Account{
- Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
- },
- ID: [2]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[[2]byte]*ClientConn{
- [2]byte{0, 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: [2]byte{0, 1},
- },
- [2]byte{0, 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: [2]byte{0, 2},
},
- },
+ )
+ return &m
+ }(),
},
},
t: Transaction{
want []Transaction
}{
{
- name: "returns expected transactions",
+ name: "when client 2 leaves chat",
args: args{
cc: &ClientConn{
ID: [2]byte{0, 2},
Server: &Server{
- PrivateChats: map[[4]byte]*PrivateChat{
- [4]byte{0, 0, 0, 1}: {
- 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},
+ 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[[2]byte]*ClientConn{
- [2]byte{0, 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: [2]byte{0, 1},
- },
- [2]byte{0, 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: [2]byte{0, 2},
},
- },
+ )
+ return &m
+ }(),
},
},
t: NewTransaction(TranDeleteUser, [2]byte{}, NewField(FieldChatID, []byte{0, 0, 0, 1})),
cc: &ClientConn{
ID: [2]byte{0, 1},
Server: &Server{
- Clients: map[[2]byte]*ClientConn{
- [2]byte{0, 1}: {
- ID: [2]byte{0, 1},
- Icon: []byte{0, 2},
- Flags: [2]byte{0, 3},
- UserName: []byte{0, 4},
- },
- [2]byte{0, 2}: {
- ID: [2]byte{0, 2},
- Icon: []byte{0, 2},
- Flags: [2]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{},
Account: &Account{
Access: func() accessBitmap {
var bits accessBitmap
- bits.Set(accessSendChat)
+ bits.Set(AccessSendChat)
return bits
}(),
},
UserName: []byte{0x00, 0x01},
Server: &Server{
- Clients: map[[2]byte]*ClientConn{
- [2]byte{0, 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: [2]byte{0, 1},
- },
- [2]byte{0, 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: [2]byte{0, 2},
},
- },
+ )
+ return &m
+ }(),
},
},
t: Transaction{
},
},
{
- 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[[2]byte]*ClientConn{
- [2]byte{0, 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: [2]byte{0, 1},
- },
- [2]byte{0, 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: [2]byte{0, 2},
},
- },
+ )
+ return &m
+ }(),
},
},
t: Transaction{
}(),
},
Server: &Server{
- Accounts: map[string]*Account{},
+ //Accounts: map[string]*Account{},
},
},
t: NewTransaction(
Account: &Account{
Access: func() accessBitmap {
var bits accessBitmap
- bits.Set(accessSendChat)
+ bits.Set(AccessSendChat)
return bits
}(),
},
UserName: []byte("Testy McTest"),
Server: &Server{
- Clients: map[[2]byte]*ClientConn{
- [2]byte{0, 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: [2]byte{0, 1},
- },
- [2]byte{0, 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: [2]byte{0, 2},
},
- },
+ )
+ return &m
+ }(),
},
},
t: Transaction{
Account: &Account{
Access: func() accessBitmap {
var bits accessBitmap
- bits.Set(accessSendChat)
+ bits.Set(AccessSendChat)
return bits
}(),
},
UserName: []byte("Testy McTest"),
Server: &Server{
- Clients: map[[2]byte]*ClientConn{
- [2]byte{0, 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: [2]byte{0, 1},
- },
- [2]byte{0, 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: [2]byte{0, 2},
},
- },
+ )
+ return &m
+ }(),
},
},
t: Transaction{
},
},
{
- 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[[2]byte]*ClientConn{
- [2]byte{0, 1}: {
- Account: &Account{
- Access: func() accessBitmap {
- var bits accessBitmap
- bits.Set(accessReadChat)
- return bits
- }()},
- ID: [2]byte{0, 1},
- },
- [2]byte{0, 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: [2]byte{0, 2},
},
- },
+ )
+ return &m
+ }(),
},
},
t: Transaction{
Account: &Account{
Access: func() accessBitmap {
var bits accessBitmap
- bits.Set(accessSendChat)
+ bits.Set(AccessSendChat)
return bits
}(),
},
UserName: []byte{0x00, 0x01},
Server: &Server{
- PrivateChats: map[[4]byte]*PrivateChat{
- [4]byte{0, 0, 0, 1}: {
- ClientConn: map[[2]byte]*ClientConn{
- [2]byte{0, 1}: {
- ID: [2]byte{0, 1},
- },
- [2]byte{0, 2}: {
- ID: [2]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[[2]byte]*ClientConn{
- [2]byte{0, 1}: {
- Account: &Account{
- Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
+ {
+ ID: [2]byte{0, 2},
},
- ID: [2]byte{0, 1},
- },
- [2]byte{0, 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: [2]byte{0, 2},
- },
- [2]byte{0, 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: [2]byte{0, 3},
},
- },
+ )
+ return &m
+ }(),
},
},
t: Transaction{
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")
Account: &Account{
Access: func() accessBitmap {
var bits accessBitmap
- bits.Set(accessCreateFolder)
+ bits.Set(AccessCreateFolder)
return bits
}(),
},
ID: [2]byte{0, 1},
Server: &Server{
- Config: &Config{
+ Config: Config{
FileRoot: "/Files/",
},
FS: func() *MockFileStore {
Account: &Account{
Access: func() accessBitmap {
var bits accessBitmap
- bits.Set(accessCreateFolder)
+ bits.Set(AccessCreateFolder)
return bits
}(),
},
ID: [2]byte{0, 1},
Server: &Server{
- Config: &Config{
+ Config: Config{
FileRoot: "/Files",
},
FS: func() *MockFileStore {
Account: &Account{
Access: func() accessBitmap {
var bits accessBitmap
- bits.Set(accessCreateFolder)
+ bits.Set(AccessCreateFolder)
return bits
}(),
},
ID: [2]byte{0, 1},
Server: &Server{
- Config: &Config{
+ Config: Config{
FileRoot: "/Files/",
},
FS: func() *MockFileStore {
Account: &Account{
Access: func() accessBitmap {
var bits accessBitmap
- bits.Set(accessCreateFolder)
+ bits.Set(AccessCreateFolder)
return bits
}(),
},
ID: [2]byte{0, 1},
Server: &Server{
- Config: &Config{
+ Config: Config{
FileRoot: "/Files/",
},
FS: func() *MockFileStore {
Account: &Account{
Access: func() accessBitmap {
var bits accessBitmap
- bits.Set(accessCreateFolder)
+ bits.Set(AccessCreateFolder)
return bits
}(),
},
ID: [2]byte{0, 1},
Server: &Server{
- Config: &Config{
+ Config: Config{
FileRoot: "/Files/",
},
FS: func() *MockFileStore {
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
}(),
},
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"
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"
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"
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(
}(),
},
Server: &Server{
- Accounts: map[string]*Account{},
+ //Accounts: map[string]*Account{},
},
},
t: NewTransaction(
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(
wantRes []Transaction
}{
{
- 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
}(),
},
},
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(
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(
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(
}(),
},
Server: &Server{
- Accounts: map[string]*Account{},
+ //Accounts: map[string]*Account{},
},
},
t: NewTransaction(
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, [2]byte{0, 1},
- NewField(FieldUserLogin, []byte("userB")),
+ NewField(FieldUserLogin, encodeString([]byte("userB"))),
NewField(
FieldUserAccess,
func() []byte {
var bits accessBitmap
- bits.Set(accessDisconUser)
+ bits.Set(AccessDisconUser)
return bits[:]
}(),
),
}(),
},
Server: &Server{
- Accounts: map[string]*Account{},
+ //Accounts: map[string]*Account{},
},
},
t: NewTransaction(
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(
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(
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
}(),
},
//
// 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(
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(
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 {
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(
args: args{
cc: &ClientConn{
Server: &Server{
- Clients: map[[2]byte]*ClientConn{
- [2]byte{0, 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
}(),
},
Account: &Account{
Access: func() accessBitmap {
var bits accessBitmap
- bits.Set(accessSendPrivMsg)
+ bits.Set(AccessSendPrivMsg)
return bits
}(),
},
ID: [2]byte{0, 1},
UserName: []byte("User1"),
Server: &Server{
- Clients: map[[2]byte]*ClientConn{
- [2]byte{0, 2}: {
+ ClientMgr: func() *MockClientMgr {
+ m := MockClientMgr{}
+ m.On("Get", ClientID{0x0, 0x2}).Return(&ClientConn{
AutoReply: []byte(nil),
Flags: [2]byte{0, 0},
},
- },
+ )
+ return &m
+ }(),
},
},
t: NewTransaction(
Account: &Account{
Access: func() accessBitmap {
var bits accessBitmap
- bits.Set(accessSendPrivMsg)
+ bits.Set(AccessSendPrivMsg)
return bits
}(),
},
ID: [2]byte{0, 1},
UserName: []byte("User1"),
Server: &Server{
- Clients: map[[2]byte]*ClientConn{
- [2]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(
Account: &Account{
Access: func() accessBitmap {
var bits accessBitmap
- bits.Set(accessSendPrivMsg)
+ bits.Set(AccessSendPrivMsg)
return bits
}(),
},
ID: [2]byte{0, 1},
UserName: []byte("User1"),
Server: &Server{
- Clients: map[[2]byte]*ClientConn{
- [2]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(
}(),
},
Server: &Server{
- Config: &Config{
+ Config: Config{
FileRoot: func() string {
return "/fakeRoot/Files"
}(),
return mfs
}(),
- Accounts: map[string]*Account{},
+ //Accounts: map[string]*Account{},
},
},
t: NewTransaction(
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"
}(),
return mfs
}(),
- Accounts: map[string]*Account{},
+ //Accounts: map[string]*Account{},
},
},
t: NewTransaction(
wantRes []Transaction
}{
{
- 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{
},
Server: &Server{
- Config: &Config{
+ Config: Config{
FileRoot: func() string {
path, _ := os.Getwd()
return filepath.Join(path, "/test/config/Files/getFileNameListTestDir")
args: args{
cc: &ClientConn{
Server: &Server{
- Config: &Config{
+ Config: Config{
FileRoot: func() string {
path, _ := os.Getwd()
return filepath.Join(path, "/test/config/Files/getFileNameListTestDir")
}(),
},
Server: &Server{
- Accounts: map[string]*Account{},
+ //Accounts: map[string]*Account{},
},
},
t: NewTransaction(
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[[2]byte]*ClientConn{
- [2]byte{0, 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, [2]byte{0, 1},
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},
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(
wantRes []Transaction
}{
{
- name: "when client does not have accessAnyName",
+ name: "when client does not have AccessAnyName",
args: args{
cc: &ClientConn{
Account: &Account{
UserName: []byte("Guest"),
Flags: [2]byte{0, 1},
Server: &Server{
- Clients: map[[2]byte]*ClientConn{
- [2]byte{0, 1}: {
- ID: [2]byte{0, 1},
- },
- },
+ ClientMgr: func() *MockClientMgr {
+ m := MockClientMgr{}
+ m.On("List").Return([]*ClientConn{
+ {
+ ID: [2]byte{0, 1},
+ },
+ })
+ return &m
+ }(),
},
},
t: NewTransaction(
},
ID: [2]byte{0, 1},
Server: &Server{
- ThreadedNews: &ThreadedNews{Categories: map[string]NewsCategoryListData15{
- "test": {
- Type: [2]byte{0, 3},
- Name: "zz",
- },
- }},
+ ThreadedNewsMgr: func() *mockThreadNewsMgr {
+ m := mockThreadNewsMgr{}
+ m.On("NewsItem", []string{"test"}).Return(NewsCategoryListData15{
+ Type: NewsCategory,
+ })
+ return &m
+ }(),
},
},
t: NewTransaction(
},
ID: [2]byte{0, 1},
Server: &Server{
- ThreadedNews: &ThreadedNews{Categories: map[string]NewsCategoryListData15{
- "testcat": {
- Type: [2]byte{0, 2},
- Name: "test",
- },
- }},
+ ThreadedNewsMgr: func() *mockThreadNewsMgr {
+ m := mockThreadNewsMgr{}
+ m.On("NewsItem", []string{"test"}).Return(NewsCategoryListData15{
+ Type: NewsBundle,
+ })
+ return &m
+ }(),
},
},
t: NewTransaction(
Account: &Account{
Access: func() accessBitmap {
var bits accessBitmap
- bits.Set(accessNewsDeleteFldr)
+ bits.Set(AccessNewsDeleteFldr)
return bits
}(),
},
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: [2]byte{0, 2},
- Name: "test",
- },
- }},
},
},
t: NewTransaction(
args: args{
cc: &ClientConn{
Account: &Account{
- Access: func() accessBitmap {
- var bits accessBitmap
- return bits
- }(),
+ Access: accessBitmap{},
},
},
t: NewTransaction(
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(
Account: &Account{
Access: func() accessBitmap {
var bits accessBitmap
- bits.Set(accessOpenChat)
+ bits.Set(AccessOpenChat)
return bits
}(),
},
Icon: []byte{0, 1},
Flags: [2]byte{0, 0},
Server: &Server{
- Clients: map[[2]byte]*ClientConn{
- [2]byte{0, 2}: {
+ ClientMgr: func() *MockClientMgr {
+ m := MockClientMgr{}
+ m.On("Get", ClientID{0x0, 0x2}).Return(&ClientConn{
ID: [2]byte{0, 2},
UserName: []byte("UserB"),
- },
- },
- PrivateChats: make(map[[4]byte]*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(
NewField(FieldUserID, []byte{0, 1}),
},
},
-
{
clientID: [2]byte{0, 1},
IsReply: 0x01,
Account: &Account{
Access: func() accessBitmap {
var bits accessBitmap
- bits.Set(accessOpenChat)
+ bits.Set(AccessOpenChat)
return bits
}(),
},
Icon: []byte{0, 1},
Flags: [2]byte{0, 0},
Server: &Server{
- Clients: map[[2]byte]*ClientConn{
- [2]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: [2]byte{255, 255},
- },
- },
- PrivateChats: make(map[[4]byte]*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(
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
+
gotRes := HandleInviteNewChat(tt.args.cc, &tt.args.t)
tranAssertEqual(t, tt.wantRes, gotRes)
}{
{
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, [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{
{
- IsReply: 0x01,
- ErrorCode: [4]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")),
},
},
},
}(),
},
Server: &Server{
- Accounts: map[string]*Account{},
+ //Accounts: map[string]*Account{},
},
},
t: NewTransaction(
},
},
},
- {
- 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{
- ThreadedNews: &ThreadedNews{
- Categories: map[string]NewsCategoryListData15{
- "Example Category": {
- Type: [2]byte{0, 2},
- Name: "",
- Articles: map[uint32]*NewsArtData{
- uint32(1): {
- Title: "testTitle",
- Poster: "testPoster",
- Data: "testBody",
- },
- },
- SubCats: nil,
- GUID: [16]byte{},
- AddSN: [4]byte{},
- DeleteSN: [4]byte{},
- },
- },
- },
-
- //Accounts: map[string]*Account{
- // "guest": {
- // Name: "guest",
- // Login: "guest",
- // Password: "zz",
- // Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
- // },
- //},
- },
- },
- 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,
- },
- ),
- },
- },
- },
- },
+ //{
+ // 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) {
}(),
},
Server: &Server{
- Accounts: map[string]*Account{},
+ //Accounts: map[string]*Account{},
},
},
t: NewTransaction(
Account: &Account{
Access: func() accessBitmap {
var bits accessBitmap
- bits.Set(accessNewsCreateFldr)
+ bits.Set(AccessNewsCreateFldr)
return bits
}(),
},
logger: NewTestLogger(),
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: [2]byte{0, 2},
- Name: "test",
- SubCats: make(map[string]NewsCategoryListData15),
- },
- }},
},
},
t: NewTransaction(
// Account: &Account{
// Access: func() accessBitmap {
// var bits accessBitmap
- // bits.Set(accessNewsCreateFldr)
+ // bits.Set(AccessNewsCreateFldr)
// return bits
// }(),
// },
// logger: NewTestLogger(),
- // ID: [2]byte{0, 1},
+ // Type: [2]byte{0, 1},
// Server: &Server{
// ConfigDir: "/fakeConfigRoot",
// FS: func() *MockFileStore {
args: args{
cc: &ClientConn{
Server: &Server{
- FS: func() *MockFileStore {
- mfs := &MockFileStore{}
- mfs.On("WriteFile", "ThreadedNews.yaml", mock.Anything, mock.Anything).Return(nil, os.ErrNotExist)
- return mfs
+ ThreadedNewsMgr: func() *mockThreadNewsMgr {
+ m := mockThreadNewsMgr{}
+ m.On("PostArticle", []string{"www"}, uint32(0), mock.AnythingOfType("hotline.NewsArtData")).Return(nil)
+ return &m
}(),
- mux: sync.Mutex{},
- threadedNewsMux: sync.Mutex{},
- ThreadedNews: &ThreadedNews{
- Categories: map[string]NewsCategoryListData15{
- "www": {
- Type: [2]byte{},
- Name: "www",
- Articles: map[uint32]*NewsArtData{},
- SubCats: nil,
- GUID: [16]byte{},
- AddSN: [4]byte{},
- DeleteSN: [4]byte{},
- readOffset: 0,
- },
- },
- },
},
Account: &Account{
Access: func() accessBitmap {
var bits accessBitmap
- bits.Set(accessNewsPostArt)
+ bits.Set(AccessNewsPostArt)
return bits
}(),
},
git.r.bdr.sh / rbdr / mobius / blobdiff