850 lines
29 KiB
Go
850 lines
29 KiB
Go
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"net/http/httptest"
|
|
"runtime/debug"
|
|
"strconv"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func recordMustExist(t *testing.T, err error, errmsg string, args ...interface{}) {
|
|
if err == ErrNoRows {
|
|
t.Errorf(errmsg, args...)
|
|
} else if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func recordMustNotExist(t *testing.T, err error, errmsg string, args ...interface{}) {
|
|
if err == nil {
|
|
t.Errorf(errmsg, args...)
|
|
} else if err != ErrNoRows {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func TestUserStore(t *testing.T) {
|
|
if !gloinited {
|
|
err := gloinit()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
if !pluginsInited {
|
|
initPlugins()
|
|
}
|
|
|
|
var err error
|
|
users, err = NewMemoryUserStore(config.UserCacheCapacity)
|
|
expectNilErr(t, err)
|
|
users.(UserCache).Flush()
|
|
userStoreTest(t, 2)
|
|
users, err = NewSQLUserStore()
|
|
expectNilErr(t, err)
|
|
userStoreTest(t, 3)
|
|
}
|
|
func userStoreTest(t *testing.T, newUserID int) {
|
|
ucache, hasCache := users.(UserCache)
|
|
// Go doesn't have short-circuiting, so this'll allow us to do one liner tests
|
|
if !hasCache {
|
|
ucache = &NullUserStore{}
|
|
}
|
|
expect(t, (!hasCache || ucache.Length() == 0), fmt.Sprintf("The initial ucache length should be zero, not %d", ucache.Length()))
|
|
|
|
_, err := users.Get(-1)
|
|
recordMustNotExist(t, err, "UID #-1 shouldn't exist")
|
|
expect(t, !hasCache || ucache.Length() == 0, fmt.Sprintf("We found %d items in the user cache and it's supposed to be empty", ucache.Length()))
|
|
|
|
_, err = users.Get(0)
|
|
recordMustNotExist(t, err, "UID #0 shouldn't exist")
|
|
expect(t, !hasCache || ucache.Length() == 0, fmt.Sprintf("We found %d items in the user cache and it's supposed to be empty", ucache.Length()))
|
|
|
|
user, err := users.Get(1)
|
|
recordMustExist(t, err, "Couldn't find UID #1")
|
|
|
|
expect(t, user.ID == 1, fmt.Sprintf("user.ID should be 1. Got '%d' instead.", user.ID))
|
|
expect(t, user.Name == "Admin", fmt.Sprintf("user.Name should be 'Admin', not '%s'", user.Name))
|
|
expect(t, user.Group == 1, "Admin should be in group 1")
|
|
expect(t, user.IsSuperAdmin, "Admin should be a super admin")
|
|
expect(t, user.IsAdmin, "Admin should be an admin")
|
|
expect(t, user.IsSuperMod, "Admin should be a super mod")
|
|
expect(t, user.IsMod, "Admin should be a mod")
|
|
expect(t, !user.IsBanned, "Admin should not be banned")
|
|
|
|
_, err = users.Get(newUserID)
|
|
recordMustNotExist(t, err, fmt.Sprintf("UID #%d shouldn't exist", newUserID))
|
|
|
|
if hasCache {
|
|
expectIntToBeX(t, ucache.Length(), 1, "User cache length should be 1, not %d")
|
|
|
|
_, err = ucache.CacheGet(-1)
|
|
recordMustNotExist(t, err, "UID #-1 shouldn't exist, even in the cache")
|
|
_, err = ucache.CacheGet(0)
|
|
recordMustNotExist(t, err, "UID #0 shouldn't exist, even in the cache")
|
|
user, err = ucache.CacheGet(1)
|
|
recordMustExist(t, err, "Couldn't find UID #1 in the cache")
|
|
|
|
if user.ID != 1 {
|
|
t.Error("user.ID does not match the requested UID. Got '" + strconv.Itoa(user.ID) + "' instead.")
|
|
}
|
|
if user.Name != "Admin" {
|
|
t.Error("user.Name should be 'Admin', not '" + user.Name + "'")
|
|
}
|
|
|
|
_, err = ucache.CacheGet(newUserID)
|
|
recordMustNotExist(t, err, "UID #%d shouldn't exist, even in the cache", newUserID)
|
|
|
|
ucache.Flush()
|
|
expectIntToBeX(t, ucache.Length(), 0, "User cache length should be 0, not %d")
|
|
}
|
|
|
|
// TODO: Lock onto the specific error type. Is this even possible without sacrificing the detailed information in the error message?
|
|
var userList map[int]*User
|
|
userList, _ = users.BulkGetMap([]int{-1})
|
|
if len(userList) > 0 {
|
|
t.Error("There shouldn't be any results for UID #-1")
|
|
}
|
|
|
|
if hasCache {
|
|
expectIntToBeX(t, ucache.Length(), 0, "User cache length should be 0, not %d")
|
|
}
|
|
|
|
userList, _ = users.BulkGetMap([]int{0})
|
|
if len(userList) > 0 {
|
|
t.Error("There shouldn't be any results for UID #0")
|
|
}
|
|
|
|
if hasCache {
|
|
expectIntToBeX(t, ucache.Length(), 0, "User cache length should be 0, not %d")
|
|
}
|
|
|
|
userList, _ = users.BulkGetMap([]int{1})
|
|
if len(userList) == 0 {
|
|
t.Error("The returned map is empty for UID #1")
|
|
} else if len(userList) > 1 {
|
|
t.Error("Too many results were returned for UID #1")
|
|
}
|
|
|
|
user, ok := userList[1]
|
|
if !ok {
|
|
t.Error("We couldn't find UID #1 in the returned map")
|
|
t.Error("userList", userList)
|
|
}
|
|
|
|
if user.ID != 1 {
|
|
t.Error("user.ID does not match the requested UID. Got '" + strconv.Itoa(user.ID) + "' instead.")
|
|
}
|
|
|
|
if hasCache {
|
|
expectIntToBeX(t, ucache.Length(), 1, "User cache length should be 1, not %d")
|
|
user, err = ucache.CacheGet(1)
|
|
recordMustExist(t, err, "Couldn't find UID #1 in the cache")
|
|
|
|
if user.ID != 1 {
|
|
t.Errorf("user.ID does not match the requested UID. Got '%d' instead.", user.ID)
|
|
}
|
|
ucache.Flush()
|
|
}
|
|
|
|
expect(t, !users.Exists(-1), "UID #-1 shouldn't exist")
|
|
expect(t, !users.Exists(0), "UID #0 shouldn't exist")
|
|
expect(t, users.Exists(1), "UID #1 should exist")
|
|
expect(t, !users.Exists(newUserID), fmt.Sprintf("UID #%d shouldn't exist", newUserID))
|
|
|
|
expect(t, !hasCache || ucache.Length() == 0, fmt.Sprintf("User cache length should be 0, not %d", ucache.Length()))
|
|
expectIntToBeX(t, users.GlobalCount(), 1, "The number of users should be one, not %d")
|
|
|
|
var awaitingActivation = 5
|
|
uid, err := users.Create("Sam", "ReallyBadPassword", "sam@localhost.loc", awaitingActivation, false)
|
|
expectNilErr(t, err)
|
|
expect(t, uid == newUserID, fmt.Sprintf("The UID of the new user should be %d", newUserID))
|
|
expect(t, users.Exists(newUserID), fmt.Sprintf("UID #%d should exist", newUserID))
|
|
|
|
user, err = users.Get(newUserID)
|
|
recordMustExist(t, err, "Couldn't find UID #%d", newUserID)
|
|
if user.ID != newUserID {
|
|
t.Errorf("The UID of the user record should be %d", newUserID)
|
|
}
|
|
|
|
expect(t, user.Name == "Sam", "The user should be named Sam")
|
|
expect(t, !user.IsSuperAdmin, "Sam should not be a super admin")
|
|
expect(t, !user.IsAdmin, "Sam should not be an admin")
|
|
expect(t, !user.IsSuperMod, "Sam should not be a super mod")
|
|
expect(t, !user.IsMod, "Sam should not be a mod")
|
|
expect(t, !user.IsBanned, "Sam should not be banned")
|
|
expectIntToBeX(t, user.Group, 5, "Sam should be in group 5")
|
|
|
|
if hasCache {
|
|
expectIntToBeX(t, ucache.Length(), 1, "User cache length should be 1, not %d")
|
|
user, err = ucache.CacheGet(newUserID)
|
|
recordMustExist(t, err, "Couldn't find UID #%d in the cache", newUserID)
|
|
expect(t, user.ID == newUserID, fmt.Sprintf("user.ID does not match the requested UID. Got '%d' instead.", user.ID))
|
|
}
|
|
|
|
err = user.Activate()
|
|
expectNilErr(t, err)
|
|
expectIntToBeX(t, user.Group, 5, "Sam should still be in group 5 in this copy")
|
|
|
|
// ? - What if we change the caching mechanism so it isn't hard purged and reloaded? We'll deal with that when we come to it, but for now, this is a sign of a cache bug
|
|
if hasCache {
|
|
expectIntToBeX(t, ucache.Length(), 0, "User cache length should be 0, not %d")
|
|
_, err = ucache.CacheGet(newUserID)
|
|
recordMustNotExist(t, err, "UID #%d shouldn't be in the cache", newUserID)
|
|
}
|
|
|
|
user, err = users.Get(newUserID)
|
|
recordMustExist(t, err, "Couldn't find UID #%d", newUserID)
|
|
|
|
expect(t, user.ID == newUserID, fmt.Sprintf("The UID of the user record should be %d, not %d", newUserID, user.ID))
|
|
expect(t, !user.IsSuperAdmin, "Sam should not be a super admin")
|
|
expect(t, !user.IsAdmin, "Sam should not be an admin")
|
|
expect(t, !user.IsSuperMod, "Sam should not be a super mod")
|
|
expect(t, !user.IsMod, "Sam should not be a mod")
|
|
expect(t, !user.IsBanned, "Sam should not be banned")
|
|
|
|
expect(t, user.Group == config.DefaultGroup, fmt.Sprintf("Sam should be in group %d, not %d", config.DefaultGroup, user.Group))
|
|
|
|
// Permanent ban
|
|
duration, _ := time.ParseDuration("0")
|
|
|
|
// TODO: Attempt a double ban, double activation, and double unban
|
|
err = user.Ban(duration, 1)
|
|
expectNilErr(t, err)
|
|
expect(t, user.Group == config.DefaultGroup, fmt.Sprintf("Sam should be in group %d, not %d", config.DefaultGroup, user.Group))
|
|
|
|
if hasCache {
|
|
expectIntToBeX(t, ucache.Length(), 0, "User cache length should be 0, not %d")
|
|
_, err = ucache.CacheGet(2)
|
|
recordMustNotExist(t, err, "UID #%d shouldn't be in the cache", newUserID)
|
|
}
|
|
|
|
user, err = users.Get(newUserID)
|
|
recordMustExist(t, err, "Couldn't find UID #%d", newUserID)
|
|
if user.ID != newUserID {
|
|
t.Errorf("The UID of the user record should be %d", newUserID)
|
|
}
|
|
|
|
expect(t, !user.IsSuperAdmin, "Sam should not be a super admin")
|
|
expect(t, !user.IsAdmin, "Sam should not be an admin")
|
|
expect(t, !user.IsSuperMod, "Sam should not be a super mod")
|
|
expect(t, !user.IsMod, "Sam should not be a mod")
|
|
expect(t, user.IsBanned, "Sam should be banned")
|
|
|
|
expectIntToBeX(t, user.Group, banGroup, "Sam should be in group %d")
|
|
|
|
// TODO: Do tests against the scheduled updates table and the task system to make sure the ban exists there and gets revoked when it should
|
|
|
|
err = user.Unban()
|
|
expectNilErr(t, err)
|
|
expectIntToBeX(t, user.Group, banGroup, "Sam should still be in the ban group in this copy")
|
|
|
|
if hasCache {
|
|
expectIntToBeX(t, ucache.Length(), 0, "User cache length should be 0, not %d")
|
|
_, err = ucache.CacheGet(newUserID)
|
|
recordMustNotExist(t, err, "UID #%d shouldn't be in the cache", newUserID)
|
|
}
|
|
|
|
user, err = users.Get(newUserID)
|
|
recordMustExist(t, err, "Couldn't find UID #%d", newUserID)
|
|
expectIntToBeX(t, user.ID, newUserID, "The UID of the user record should be %d")
|
|
|
|
expect(t, !user.IsSuperAdmin, "Sam should not be a super admin")
|
|
expect(t, !user.IsAdmin, "Sam should not be an admin")
|
|
expect(t, !user.IsSuperMod, "Sam should not be a super mod")
|
|
expect(t, !user.IsMod, "Sam should not be a mod")
|
|
expect(t, !user.IsBanned, "Sam should not be banned")
|
|
|
|
expectIntToBeX(t, user.Group, config.DefaultGroup, "Sam should be back in group %d")
|
|
|
|
var reportsForumID = 1
|
|
var generalForumID = 2
|
|
dummyResponseRecorder := httptest.NewRecorder()
|
|
bytesBuffer := bytes.NewBuffer([]byte(""))
|
|
dummyRequest1 := httptest.NewRequest("", "/forum/1", bytesBuffer)
|
|
dummyRequest2 := httptest.NewRequest("", "/forum/2", bytesBuffer)
|
|
|
|
err = user.ChangeGroup(1)
|
|
expectNilErr(t, err)
|
|
expect(t, user.Group == config.DefaultGroup, "Someone's mutated this pointer elsewhere")
|
|
|
|
user, err = users.Get(newUserID)
|
|
recordMustExist(t, err, "Couldn't find UID #%d", newUserID)
|
|
expectIntToBeX(t, user.ID, newUserID, "The UID of the user record should be %d")
|
|
var user2 *User = getDummyUser()
|
|
*user2 = *user
|
|
|
|
expect(t, !user.IsSuperAdmin, "Sam should not be a super admin")
|
|
expect(t, user.IsAdmin, "Sam should be an admin")
|
|
expect(t, user.IsSuperMod, "Sam should be a super mod")
|
|
expect(t, user.IsMod, "Sam should be a mod")
|
|
expect(t, !user.IsBanned, "Sam should not be banned")
|
|
|
|
_, ferr := forumUserCheck(dummyResponseRecorder, dummyRequest1, user, reportsForumID)
|
|
expect(t, ferr == nil, "There shouldn't be any errors in forumUserCheck")
|
|
expect(t, user.Perms.ViewTopic, "Admins should be able to access the reports forum")
|
|
_, ferr = forumUserCheck(dummyResponseRecorder, dummyRequest2, user2, generalForumID)
|
|
expect(t, ferr == nil, "There shouldn't be any errors in forumUserCheck")
|
|
expect(t, user2.Perms.ViewTopic, "Sam should be able to access the general forum")
|
|
|
|
err = user.ChangeGroup(2)
|
|
expectNilErr(t, err)
|
|
expect(t, user.Group == 1, "Someone's mutated this pointer elsewhere")
|
|
|
|
user, err = users.Get(newUserID)
|
|
recordMustExist(t, err, "Couldn't find UID #%d", newUserID)
|
|
expectIntToBeX(t, user.ID, newUserID, "The UID of the user record should be %d")
|
|
user2 = getDummyUser()
|
|
*user2 = *user
|
|
|
|
expect(t, !user.IsSuperAdmin, "Sam should not be a super admin")
|
|
expect(t, !user.IsAdmin, "Sam should not be an admin")
|
|
expect(t, user.IsSuperMod, "Sam should be a super mod")
|
|
expect(t, user.IsMod, "Sam should be a mod")
|
|
expect(t, !user.IsBanned, "Sam should not be banned")
|
|
|
|
_, ferr = forumUserCheck(dummyResponseRecorder, dummyRequest1, user, reportsForumID)
|
|
expect(t, ferr == nil, "There shouldn't be any errors in forumUserCheck")
|
|
expect(t, user.Perms.ViewTopic, "Mods should be able to access the reports forum")
|
|
_, ferr = forumUserCheck(dummyResponseRecorder, dummyRequest2, user2, generalForumID)
|
|
expect(t, ferr == nil, "There shouldn't be any errors in forumUserCheck")
|
|
expect(t, user2.Perms.ViewTopic, "Sam should be able to access the general forum")
|
|
|
|
err = user.ChangeGroup(3)
|
|
expectNilErr(t, err)
|
|
expect(t, user.Group == 2, "Someone's mutated this pointer elsewhere")
|
|
|
|
user, err = users.Get(newUserID)
|
|
recordMustExist(t, err, "Couldn't find UID #%d", newUserID)
|
|
expectIntToBeX(t, user.ID, newUserID, "The UID of the user record should be %d")
|
|
user2 = getDummyUser()
|
|
*user2 = *user
|
|
|
|
expect(t, !user.IsSuperAdmin, "Sam should not be a super admin")
|
|
expect(t, !user.IsAdmin, "Sam should not be an admin")
|
|
expect(t, !user.IsSuperMod, "Sam should not be a super mod")
|
|
expect(t, !user.IsMod, "Sam should not be a mod")
|
|
expect(t, !user.IsBanned, "Sam should not be banned")
|
|
|
|
_, ferr = forumUserCheck(dummyResponseRecorder, dummyRequest1, user, reportsForumID)
|
|
expect(t, ferr == nil, "There shouldn't be any errors in forumUserCheck")
|
|
expect(t, !user.Perms.ViewTopic, "Members shouldn't be able to access the reports forum")
|
|
_, ferr = forumUserCheck(dummyResponseRecorder, dummyRequest2, user2, generalForumID)
|
|
expect(t, ferr == nil, "There shouldn't be any errors in forumUserCheck")
|
|
expect(t, user2.Perms.ViewTopic, "Sam should be able to access the general forum")
|
|
expect(t, user.Perms.ViewTopic != user2.Perms.ViewTopic, "user.Perms.ViewTopic and user2.Perms.ViewTopic should never match")
|
|
|
|
err = user.ChangeGroup(4)
|
|
expectNilErr(t, err)
|
|
expect(t, user.Group == 3, "Someone's mutated this pointer elsewhere")
|
|
|
|
user, err = users.Get(newUserID)
|
|
recordMustExist(t, err, "Couldn't find UID #%d", newUserID)
|
|
expectIntToBeX(t, user.ID, newUserID, "The UID of the user record should be %d")
|
|
user2 = getDummyUser()
|
|
*user2 = *user
|
|
|
|
expect(t, !user.IsSuperAdmin, "Sam should not be a super admin")
|
|
expect(t, !user.IsAdmin, "Sam should not be an admin")
|
|
expect(t, !user.IsSuperMod, "Sam should not be a super mod")
|
|
expect(t, !user.IsMod, "Sam should not be a mod")
|
|
expect(t, user.IsBanned, "Sam should be banned")
|
|
|
|
_, ferr = forumUserCheck(dummyResponseRecorder, dummyRequest1, user, reportsForumID)
|
|
expect(t, ferr == nil, "There shouldn't be any errors in forumUserCheck")
|
|
expect(t, !user.Perms.ViewTopic, "Members shouldn't be able to access the reports forum")
|
|
_, ferr = forumUserCheck(dummyResponseRecorder, dummyRequest2, user2, generalForumID)
|
|
expect(t, ferr == nil, "There shouldn't be any errors in forumUserCheck")
|
|
expect(t, user2.Perms.ViewTopic, "Sam should be able to access the general forum")
|
|
|
|
err = user.ChangeGroup(5)
|
|
expectNilErr(t, err)
|
|
expect(t, user.Group == 4, "Someone's mutated this pointer elsewhere")
|
|
|
|
user, err = users.Get(newUserID)
|
|
recordMustExist(t, err, "Couldn't find UID #%d", newUserID)
|
|
expectIntToBeX(t, user.ID, newUserID, "The UID of the user record should be %d")
|
|
user2 = getDummyUser()
|
|
*user2 = *user
|
|
|
|
expect(t, !user.IsSuperAdmin, "Sam should not be a super admin")
|
|
expect(t, !user.IsAdmin, "Sam should not be an admin")
|
|
expect(t, !user.IsSuperMod, "Sam should not be a super mod")
|
|
expect(t, !user.IsMod, "Sam should not be a mod")
|
|
expect(t, !user.IsBanned, "Sam should not be banned")
|
|
|
|
_, ferr = forumUserCheck(dummyResponseRecorder, dummyRequest1, user, reportsForumID)
|
|
expect(t, ferr == nil, "There shouldn't be any errors in forumUserCheck")
|
|
expect(t, !user.Perms.ViewTopic, "Members shouldn't be able to access the reports forum")
|
|
_, ferr = forumUserCheck(dummyResponseRecorder, dummyRequest2, user2, generalForumID)
|
|
expect(t, ferr == nil, "There shouldn't be any errors in forumUserCheck")
|
|
expect(t, user2.Perms.ViewTopic, "Sam should be able to access the general forum")
|
|
|
|
err = user.ChangeGroup(6)
|
|
expectNilErr(t, err)
|
|
expect(t, user.Group == 5, "Someone's mutated this pointer elsewhere")
|
|
|
|
user, err = users.Get(newUserID)
|
|
recordMustExist(t, err, "Couldn't find UID #%d", newUserID)
|
|
expectIntToBeX(t, user.ID, newUserID, "The UID of the user record should be %d")
|
|
user2 = getDummyUser()
|
|
*user2 = *user
|
|
|
|
expect(t, !user.IsSuperAdmin, "Sam should not be a super admin")
|
|
expect(t, !user.IsAdmin, "Sam should not be an admin")
|
|
expect(t, !user.IsSuperMod, "Sam should not be a super mod")
|
|
expect(t, !user.IsMod, "Sam should not be a mod")
|
|
expect(t, !user.IsBanned, "Sam should not be banned")
|
|
|
|
_, ferr = forumUserCheck(dummyResponseRecorder, dummyRequest1, user, reportsForumID)
|
|
expect(t, ferr == nil, "There shouldn't be any errors in forumUserCheck")
|
|
expect(t, !user.Perms.ViewTopic, "Members shouldn't be able to access the reports forum")
|
|
_, ferr = forumUserCheck(dummyResponseRecorder, dummyRequest2, user2, generalForumID)
|
|
expect(t, ferr == nil, "There shouldn't be any errors in forumUserCheck")
|
|
expect(t, user2.Perms.ViewTopic, "Sam should be able to access the general forum")
|
|
|
|
err = user.ChangeGroup(config.DefaultGroup)
|
|
expectNilErr(t, err)
|
|
expect(t, user.Group == 6, "Someone's mutated this pointer elsewhere")
|
|
|
|
err = user.Delete()
|
|
expectNilErr(t, err)
|
|
expect(t, !users.Exists(newUserID), fmt.Sprintf("UID #%d should no longer exist", newUserID))
|
|
|
|
if hasCache {
|
|
expectIntToBeX(t, ucache.Length(), 0, "User cache length should be 0, not %d")
|
|
_, err = ucache.CacheGet(newUserID)
|
|
recordMustNotExist(t, err, "UID #%d shouldn't be in the cache", newUserID)
|
|
}
|
|
|
|
_, err = users.Get(newUserID)
|
|
recordMustNotExist(t, err, "UID #%d shouldn't exist", newUserID)
|
|
|
|
// TODO: Add tests for the Cache* methods
|
|
}
|
|
|
|
// TODO: Add an error message to this?
|
|
func expectNilErr(t *testing.T, item error) {
|
|
if item != nil {
|
|
debug.PrintStack()
|
|
t.Fatal(item)
|
|
}
|
|
}
|
|
|
|
func expectIntToBeX(t *testing.T, item int, expect int, errmsg string) {
|
|
if item != expect {
|
|
debug.PrintStack()
|
|
t.Fatalf(errmsg, item)
|
|
}
|
|
}
|
|
|
|
func expect(t *testing.T, item bool, errmsg string) {
|
|
if !item {
|
|
debug.PrintStack()
|
|
t.Fatal(errmsg)
|
|
}
|
|
}
|
|
|
|
func TestPermsMiddleware(t *testing.T) {
|
|
if !gloinited {
|
|
err := gloinit()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
if !pluginsInited {
|
|
initPlugins()
|
|
}
|
|
|
|
dummyResponseRecorder := httptest.NewRecorder()
|
|
bytesBuffer := bytes.NewBuffer([]byte(""))
|
|
dummyRequest := httptest.NewRequest("", "/forum/1", bytesBuffer)
|
|
user := getDummyUser()
|
|
|
|
ferr := SuperModOnly(dummyResponseRecorder, dummyRequest, *user)
|
|
expect(t, ferr != nil, "Blank users shouldn't be supermods")
|
|
|
|
user.IsSuperMod = false
|
|
ferr = SuperModOnly(dummyResponseRecorder, dummyRequest, *user)
|
|
expect(t, ferr != nil, "Non-supermods shouldn't be allowed through supermod gates")
|
|
|
|
user.IsSuperMod = true
|
|
ferr = SuperModOnly(dummyResponseRecorder, dummyRequest, *user)
|
|
expect(t, ferr == nil, "Supermods should be allowed through supermod gates")
|
|
|
|
// TODO: Loop over the Control Panel routes and make sure only supermods can get in
|
|
|
|
user = getDummyUser()
|
|
|
|
ferr = MemberOnly(dummyResponseRecorder, dummyRequest, *user)
|
|
expect(t, ferr != nil, "Blank users shouldn't be considered loggedin")
|
|
|
|
user.Loggedin = false
|
|
ferr = MemberOnly(dummyResponseRecorder, dummyRequest, *user)
|
|
expect(t, ferr != nil, "Guests shouldn't be able to access member areas")
|
|
|
|
user.Loggedin = true
|
|
ferr = MemberOnly(dummyResponseRecorder, dummyRequest, *user)
|
|
expect(t, ferr == nil, "Logged in users should be able to access member areas")
|
|
|
|
// TODO: Loop over the /user/ routes and make sure only members can access the ones other than /user/username
|
|
}
|
|
|
|
func TestTopicStore(t *testing.T) {
|
|
if !gloinited {
|
|
err := gloinit()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
if !pluginsInited {
|
|
initPlugins()
|
|
}
|
|
|
|
var err error
|
|
topics, err = NewMemoryTopicStore(config.TopicCacheCapacity)
|
|
expectNilErr(t, err)
|
|
topicStoreTest(t)
|
|
topics, err = NewSQLTopicStore()
|
|
expectNilErr(t, err)
|
|
topicStoreTest(t)
|
|
}
|
|
func topicStoreTest(t *testing.T) {
|
|
var topic *Topic
|
|
var err error
|
|
|
|
_, err = topics.Get(-1)
|
|
recordMustNotExist(t, err, "TID #-1 shouldn't exist")
|
|
|
|
_, err = topics.Get(0)
|
|
recordMustNotExist(t, err, "TID #0 shouldn't exist")
|
|
|
|
topic, err = topics.Get(1)
|
|
recordMustExist(t, err, "Couldn't find TID #1")
|
|
|
|
if topic.ID != 1 {
|
|
t.Error("topic.ID does not match the requested TID. Got '" + strconv.Itoa(topic.ID) + "' instead.")
|
|
}
|
|
|
|
// TODO: Add BulkGetMap() to the TopicStore
|
|
|
|
ok := topics.Exists(-1)
|
|
if ok {
|
|
t.Error("TID #-1 shouldn't exist")
|
|
}
|
|
|
|
ok = topics.Exists(0)
|
|
if ok {
|
|
t.Error("TID #0 shouldn't exist")
|
|
}
|
|
|
|
ok = topics.Exists(1)
|
|
if !ok {
|
|
t.Error("TID #1 should exist")
|
|
}
|
|
|
|
count := topics.GlobalCount()
|
|
if count <= 0 {
|
|
t.Error("The number of topics should be bigger than zero")
|
|
t.Error("count", count)
|
|
}
|
|
}
|
|
|
|
func TestForumStore(t *testing.T) {
|
|
if !gloinited {
|
|
gloinit()
|
|
}
|
|
if !pluginsInited {
|
|
initPlugins()
|
|
}
|
|
|
|
_, err := fstore.Get(-1)
|
|
recordMustNotExist(t, err, "FID #-1 shouldn't exist")
|
|
|
|
_, err = fstore.Get(0)
|
|
recordMustNotExist(t, err, "FID #0 shouldn't exist")
|
|
|
|
forum, err := fstore.Get(1)
|
|
recordMustExist(t, err, "Couldn't find FID #1")
|
|
|
|
if forum.ID != 1 {
|
|
t.Error("forum.ID doesn't not match the requested FID. Got '" + strconv.Itoa(forum.ID) + "' instead.'")
|
|
}
|
|
// TODO: Check the preset and forum permissions
|
|
expect(t, forum.Name == "Reports", fmt.Sprintf("FID #0 is named '%s' and not 'Reports'", forum.Name))
|
|
expect(t, !forum.Active, fmt.Sprintf("The reports forum shouldn't be active"))
|
|
var expectDesc = "All the reports go here"
|
|
expect(t, forum.Desc == expectDesc, fmt.Sprintf("The forum description should be '%s' not '%s'", expectDesc, forum.Desc))
|
|
|
|
forum, err = fstore.Get(2)
|
|
recordMustExist(t, err, "Couldn't find FID #1")
|
|
|
|
expect(t, forum.ID == 2, fmt.Sprintf("The FID should be 2 not %d", forum.ID))
|
|
expect(t, forum.Name == "General", fmt.Sprintf("The name of the forum should be 'General' not '%s'", forum.Name))
|
|
expect(t, forum.Active, fmt.Sprintf("The general forum should be active"))
|
|
expectDesc = "A place for general discussions which don't fit elsewhere"
|
|
expect(t, forum.Desc == expectDesc, fmt.Sprintf("The forum description should be '%s' not '%s'", expectDesc, forum.Desc))
|
|
|
|
ok := fstore.Exists(-1)
|
|
expect(t, !ok, "FID #-1 shouldn't exist")
|
|
ok = fstore.Exists(0)
|
|
expect(t, !ok, "FID #0 shouldn't exist")
|
|
ok = fstore.Exists(1)
|
|
expect(t, ok, "FID #1 should exist")
|
|
|
|
// TODO: Test forum creation
|
|
// TODO: Test forum deletion
|
|
// TODO: Test forum update
|
|
}
|
|
|
|
// TODO: Implement this
|
|
func TestForumPermsStore(t *testing.T) {
|
|
if !gloinited {
|
|
gloinit()
|
|
}
|
|
if !pluginsInited {
|
|
initPlugins()
|
|
}
|
|
}
|
|
|
|
// TODO: Test the group permissions
|
|
func TestGroupStore(t *testing.T) {
|
|
if !gloinited {
|
|
gloinit()
|
|
}
|
|
if !pluginsInited {
|
|
initPlugins()
|
|
}
|
|
|
|
_, err := gstore.Get(-1)
|
|
recordMustNotExist(t, err, "GID #-1 shouldn't exist")
|
|
|
|
// TODO: Refactor the group store to remove GID #0
|
|
group, err := gstore.Get(0)
|
|
recordMustExist(t, err, "Couldn't find GID #0")
|
|
|
|
if group.ID != 0 {
|
|
t.Errorf("group.ID doesn't not match the requested GID. Got '%d' instead.", group.ID)
|
|
}
|
|
expect(t, group.Name == "Unknown", fmt.Sprintf("GID #0 is named '%s' and not 'Unknown'", group.Name))
|
|
|
|
group, err = gstore.Get(1)
|
|
recordMustExist(t, err, "Couldn't find GID #1")
|
|
|
|
if group.ID != 1 {
|
|
t.Errorf("group.ID doesn't not match the requested GID. Got '%d' instead.'", group.ID)
|
|
}
|
|
|
|
ok := gstore.Exists(-1)
|
|
expect(t, !ok, "GID #-1 shouldn't exist")
|
|
|
|
// 0 aka Unknown, for system posts and other oddities
|
|
ok = gstore.Exists(0)
|
|
expect(t, ok, "GID #0 should exist")
|
|
|
|
ok = gstore.Exists(1)
|
|
expect(t, ok, "GID #1 should exist")
|
|
|
|
var isAdmin = true
|
|
var isMod = true
|
|
var isBanned = false
|
|
gid, err := gstore.Create("Testing", "Test", isAdmin, isMod, isBanned)
|
|
expectNilErr(t, err)
|
|
expect(t, gstore.Exists(gid), "The group we just made doesn't exist")
|
|
|
|
group, err = gstore.Get(gid)
|
|
expectNilErr(t, err)
|
|
expect(t, group.ID == gid, "The group ID should match the requested ID")
|
|
expect(t, group.IsAdmin, "This should be an admin group")
|
|
expect(t, group.IsMod, "This should be a mod group")
|
|
expect(t, !group.IsBanned, "This shouldn't be a ban group")
|
|
|
|
isAdmin = false
|
|
isMod = true
|
|
isBanned = true
|
|
gid, err = gstore.Create("Testing 2", "Test", isAdmin, isMod, isBanned)
|
|
expectNilErr(t, err)
|
|
expect(t, gstore.Exists(gid), "The group we just made doesn't exist")
|
|
|
|
group, err = gstore.Get(gid)
|
|
expectNilErr(t, err)
|
|
expect(t, group.ID == gid, "The group ID should match the requested ID")
|
|
expect(t, !group.IsAdmin, "This should not be an admin group")
|
|
expect(t, group.IsMod, "This should be a mod group")
|
|
expect(t, !group.IsBanned, "This shouldn't be a ban group")
|
|
|
|
// TODO: Make sure this pointer doesn't change once we refactor the group store to stop updating the pointer
|
|
err = group.ChangeRank(false, false, true)
|
|
expectNilErr(t, err)
|
|
|
|
group, err = gstore.Get(gid)
|
|
expectNilErr(t, err)
|
|
expect(t, group.ID == gid, "The group ID should match the requested ID")
|
|
expect(t, !group.IsAdmin, "This shouldn't be an admin group")
|
|
expect(t, !group.IsMod, "This shouldn't be a mod group")
|
|
expect(t, group.IsBanned, "This should be a ban group")
|
|
|
|
err = group.ChangeRank(true, true, true)
|
|
expectNilErr(t, err)
|
|
|
|
group, err = gstore.Get(gid)
|
|
expectNilErr(t, err)
|
|
expect(t, group.ID == gid, "The group ID should match the requested ID")
|
|
expect(t, group.IsAdmin, "This should be an admin group")
|
|
expect(t, group.IsMod, "This should be a mod group")
|
|
expect(t, !group.IsBanned, "This shouldn't be a ban group")
|
|
|
|
err = group.ChangeRank(false, true, true)
|
|
expectNilErr(t, err)
|
|
|
|
group, err = gstore.Get(gid)
|
|
expectNilErr(t, err)
|
|
expect(t, group.ID == gid, "The group ID should match the requested ID")
|
|
expect(t, !group.IsAdmin, "This shouldn't be an admin group")
|
|
expect(t, group.IsMod, "This should be a mod group")
|
|
expect(t, !group.IsBanned, "This shouldn't be a ban group")
|
|
|
|
// Make sure the data is static
|
|
gstore.Reload(gid)
|
|
|
|
group, err = gstore.Get(gid)
|
|
expectNilErr(t, err)
|
|
expect(t, group.ID == gid, "The group ID should match the requested ID")
|
|
expect(t, !group.IsAdmin, "This shouldn't be an admin group")
|
|
expect(t, group.IsMod, "This should be a mod group")
|
|
expect(t, !group.IsBanned, "This shouldn't be a ban group")
|
|
|
|
// TODO: Test group deletion
|
|
// TODO: Test group reload
|
|
// TODO: Test group cache set
|
|
}
|
|
|
|
func TestReplyStore(t *testing.T) {
|
|
if !gloinited {
|
|
gloinit()
|
|
}
|
|
if !pluginsInited {
|
|
initPlugins()
|
|
}
|
|
|
|
_, err := rstore.Get(-1)
|
|
recordMustNotExist(t, err, "RID #-1 shouldn't exist")
|
|
|
|
_, err = rstore.Get(0)
|
|
recordMustNotExist(t, err, "RID #0 shouldn't exist")
|
|
|
|
reply, err := rstore.Get(1)
|
|
expectNilErr(t, err)
|
|
|
|
if reply.ID != 1 {
|
|
t.Errorf("RID #1 has the wrong ID. It should be 1 not %d", reply.ID)
|
|
}
|
|
if reply.ParentID != 1 {
|
|
t.Errorf("The parent topic of RID #1 should be 1 not %d", reply.ParentID)
|
|
}
|
|
if reply.CreatedBy != 1 {
|
|
t.Errorf("The creator of RID #1 should be 1 not %d", reply.CreatedBy)
|
|
}
|
|
}
|
|
|
|
func TestProfileReplyStore(t *testing.T) {
|
|
if !gloinited {
|
|
gloinit()
|
|
}
|
|
if !pluginsInited {
|
|
initPlugins()
|
|
}
|
|
|
|
_, err := prstore.Get(-1)
|
|
recordMustNotExist(t, err, "RID #-1 shouldn't exist")
|
|
|
|
_, err = prstore.Get(0)
|
|
recordMustNotExist(t, err, "RID #0 shouldn't exist")
|
|
}
|
|
|
|
func TestSlugs(t *testing.T) {
|
|
var res string
|
|
var msgList []MEPair
|
|
|
|
msgList = addMEPair(msgList, "Unknown", "unknown")
|
|
msgList = addMEPair(msgList, "Unknown2", "unknown2")
|
|
msgList = addMEPair(msgList, "Unknown ", "unknown")
|
|
msgList = addMEPair(msgList, "Unknown 2", "unknown-2")
|
|
msgList = addMEPair(msgList, "Unknown 2", "unknown-2")
|
|
msgList = addMEPair(msgList, "Admin Alice", "admin-alice")
|
|
msgList = addMEPair(msgList, "Admin_Alice", "adminalice")
|
|
msgList = addMEPair(msgList, "Admin_Alice-", "adminalice")
|
|
msgList = addMEPair(msgList, "-Admin_Alice-", "adminalice")
|
|
msgList = addMEPair(msgList, "-Admin@Alice-", "adminalice")
|
|
msgList = addMEPair(msgList, "-Admin😀Alice-", "adminalice")
|
|
msgList = addMEPair(msgList, "u", "u")
|
|
msgList = addMEPair(msgList, "", "untitled")
|
|
msgList = addMEPair(msgList, " ", "untitled")
|
|
msgList = addMEPair(msgList, "-", "untitled")
|
|
msgList = addMEPair(msgList, "--", "untitled")
|
|
msgList = addMEPair(msgList, "é", "é")
|
|
msgList = addMEPair(msgList, "-é-", "é")
|
|
msgList = addMEPair(msgList, "-你好-", "untitled")
|
|
|
|
for _, item := range msgList {
|
|
t.Log("Testing string '" + item.Msg + "'")
|
|
res = nameToSlug(item.Msg)
|
|
if res != item.Expects {
|
|
t.Error("Bad output:", "'"+res+"'")
|
|
t.Error("Expected:", item.Expects)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestAuth(t *testing.T) {
|
|
// bcrypt likes doing stupid things, so this test will probably fail
|
|
var realPassword string
|
|
var hashedPassword string
|
|
var password string
|
|
var salt string
|
|
var err error
|
|
|
|
/* No extra salt tests, we might not need this extra salt, as bcrypt has it's own? */
|
|
realPassword = "Madame Cassandra's Mystic Orb"
|
|
t.Log("Set realPassword to '" + realPassword + "'")
|
|
t.Log("Hashing the real password")
|
|
hashedPassword, err = BcryptGeneratePasswordNoSalt(realPassword)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
|
|
password = realPassword
|
|
t.Log("Testing password '" + password + "'")
|
|
t.Log("Testing salt '" + salt + "'")
|
|
err = CheckPassword(hashedPassword, password, salt)
|
|
if err == ErrMismatchedHashAndPassword {
|
|
t.Error("The two don't match")
|
|
} else if err == ErrPasswordTooLong {
|
|
t.Error("CheckPassword thinks the password is too long")
|
|
} else if err != nil {
|
|
t.Error(err)
|
|
}
|
|
|
|
password = "hahaha"
|
|
t.Log("Testing password '" + password + "'")
|
|
t.Log("Testing salt '" + salt + "'")
|
|
err = CheckPassword(hashedPassword, password, salt)
|
|
if err == ErrPasswordTooLong {
|
|
t.Error("CheckPassword thinks the password is too long")
|
|
} else if err == nil {
|
|
t.Error("The two shouldn't match!")
|
|
}
|
|
|
|
password = "Madame Cassandra's Mystic"
|
|
t.Log("Testing password '" + password + "'")
|
|
t.Log("Testing salt '" + salt + "'")
|
|
err = CheckPassword(hashedPassword, password, salt)
|
|
if err == ErrPasswordTooLong {
|
|
t.Error("CheckPassword thinks the password is too long")
|
|
} else if err == nil {
|
|
t.Error("The two shouldn't match!")
|
|
}
|
|
}
|