1
Fork 0
mirror of https://github.com/jech/galene.git synced 2024-12-22 23:35:46 +01:00
galene/group/group_test.go
Juliusz Chroboczek 07f4aab9b1 Add new "caption" permission.
It is required for displaying captions.
2024-11-08 15:22:41 +01:00

350 lines
7.9 KiB
Go

package group
import (
"encoding/json"
"errors"
"fmt"
"sort"
"testing"
"time"
)
func TestGroup(t *testing.T) {
groups.groups = nil
Add("group", &Description{})
Add("group/subgroup", &Description{Public: true})
if len(groups.groups) != 2 {
t.Errorf("Expected 2, got %v", len(groups.groups))
}
g := Get("group")
g2 := Get("group/subgroup")
if g == nil {
t.Fatalf("Couldn't get group")
}
if g2 == nil {
t.Fatalf("Couldn't get group/subgroup")
}
if name := g.Name(); name != "group" {
t.Errorf("Name: expected group1, got %v", name)
}
if locked, _ := g.Locked(); locked {
t.Errorf("Locked: expected false, got %v", locked)
}
api, err := g.API()
if err != nil || api == nil {
t.Errorf("Couldn't get API: %v", err)
}
if names := GetNames(); len(names) != 2 {
t.Errorf("Expected 2, got %v", names)
}
if subs := GetSubGroups("group"); len(subs) != 0 {
t.Errorf("Expected [], got %v", subs)
}
if public := GetPublic(nil); len(public) != 1 || public[0].Name != "group/subgroup" {
t.Errorf("Expected group/subgroup, got %v", public)
}
}
func TestChatHistory(t *testing.T) {
g := Group{
description: &Description{},
}
user := "user"
for i := 0; i < 2*maxChatHistory; i++ {
g.AddToChatHistory(
fmt.Sprintf("id-%v", i),
fmt.Sprintf("source-%v", i%4),
&user, time.Now(), "",
fmt.Sprintf("%v", i),
)
}
h := g.GetChatHistory()
if len(h) != maxChatHistory {
t.Errorf("Expected %v, got %v", maxChatHistory, len(g.history))
}
for i, s := range h {
j := i + maxChatHistory
if s.Id != fmt.Sprintf("id-%v", j) {
t.Errorf("Expected %v, got %v", j, s.Id)
}
if s.Source != fmt.Sprintf("source-%v", j%4) {
t.Errorf("Expected %v, got %v", j%4, s.Id)
}
if s.Value.(string) != fmt.Sprintf("%v", j) {
t.Errorf("Expected %v, got %v", j, s.Value)
}
}
l := len(h)
j := maxChatHistory + 4
g.ClearChatHistory(
fmt.Sprintf("id-%v", j), fmt.Sprintf("source-%v", j%4),
)
if lh := len(g.GetChatHistory()); lh != l-1 {
t.Errorf("Expected %v, got %v", l-1, lh)
}
g.ClearChatHistory("", fmt.Sprintf("source-%v", j%4))
if lh := len(g.GetChatHistory()); lh != l*3/4 {
t.Errorf("Expected %v, got %v", l*3/4, lh)
}
g.ClearChatHistory("", "")
if lh := len(g.GetChatHistory()); lh != 0 {
t.Errorf("Expected 0, got %v", lh)
}
}
func permissionsEqual(a, b []string) bool {
// nil case
if len(a) == 0 && len(b) == 0 {
return true
}
if len(a) != len(b) {
return false
}
aa := append([]string(nil), a...)
sort.Slice(aa, func(i, j int) bool {
return aa[i] < aa[j]
})
bb := append([]string(nil), b...)
sort.Slice(bb, func(i, j int) bool {
return bb[i] < bb[j]
})
for i := range aa {
if aa[i] != bb[i] {
return false
}
}
return true
}
var jch = "jch"
var john = "john"
var james = "james"
var paul = "paul"
var peter = "peter"
var admin = "admin"
var stt = "speech-to-text"
var badClients = []ClientCredentials{
{Username: &jch, Password: "foo"},
{Username: &john, Password: "foo"},
{Username: &james, Password: "foo"},
}
type credPerm struct {
c ClientCredentials
p []string
}
var desc2JSON = `
{
"max-history-age": 10,
"auto-subgroups": true,
"users": {
"jch": {"password": "topsecret", "permissions": "op"},
"john": {"password": "secret", "permissions": "present"},
"james": {"password": "secret2", "permissions": "message"},
"peter": {"password": "secret4"},
"admin": {"password": "admin", "permissions": "admin"},
"speech-to-text": {"password": {"type": "wildcard"},
"permissions": "caption"}
},
"wildcard-user":
{"permissions": "message", "password": {"type":"wildcard"}}
}`
var goodClients = []credPerm{
{
ClientCredentials{Username: &jch, Password: "topsecret"},
[]string{"op", "present", "message", "caption", "token"},
},
{
ClientCredentials{Username: &john, Password: "secret"},
[]string{"present", "message"},
},
{
ClientCredentials{Username: &james, Password: "secret2"},
[]string{"message"},
},
{
ClientCredentials{Username: &paul, Password: "secret3"},
[]string{"message"},
},
{
ClientCredentials{Username: &peter, Password: "secret4"},
[]string{},
},
{
ClientCredentials{Username: &admin, Password: "admin"},
[]string{"admin"},
},
{
ClientCredentials{Username: &stt},
[]string{"caption"},
},
}
func TestPermissions(t *testing.T) {
var g Group
err := json.Unmarshal([]byte(desc2JSON), &g.description)
if err != nil {
t.Fatalf("unmarshal: %v", err)
}
for _, c := range badClients {
t.Run("bad "+*c.Username, func(t *testing.T) {
var autherr *NotAuthorisedError
_, p, err := g.GetPermission(c)
if !errors.As(err, &autherr) {
t.Errorf("GetPermission %v: %v %v", c, err, p)
}
})
}
for _, cp := range goodClients {
t.Run("good "+*cp.c.Username, func(t *testing.T) {
u, p, err := g.GetPermission(cp.c)
if err != nil {
t.Errorf("GetPermission %v: %v", cp.c, err)
} else if u != *cp.c.Username ||
!permissionsEqual(p, cp.p) {
t.Errorf("%v: got %v %v, expected %v",
cp.c, u, p, cp.p)
}
})
}
}
func TestExtraPermissions(t *testing.T) {
j := `
{
"users": {
"jch": {"password": "topsecret", "permissions": "op"},
"john": {"password": "secret", "permissions": "present"},
"james": {"password": "secret2", "permissions": "observe"}
}
}`
var d Description
err := json.Unmarshal([]byte(j), &d)
if err != nil {
t.Fatalf("unmarshal: %v", err)
}
doit := func(u string, p []string) {
t.Helper()
pu := d.Users[u].Permissions.Permissions(&d)
if !permissionsEqual(pu, p) {
t.Errorf("%v: expected %v, got %v", u, p, pu)
}
}
doit("jch", []string{"op", "token", "present", "message", "caption"})
doit("john", []string{"present", "message"})
doit("james", []string{})
d.AllowRecording = true
d.UnrestrictedTokens = false
doit("jch", []string{
"op", "record", "token", "present", "message", "caption",
})
doit("john", []string{"present", "message"})
doit("james", []string{})
d.AllowRecording = false
d.UnrestrictedTokens = true
doit("jch", []string{"op", "token", "present", "message", "caption"})
doit("john", []string{"token", "present", "message"})
doit("james", []string{})
d.AllowRecording = true
d.UnrestrictedTokens = true
doit("jch", []string{
"op", "record", "token", "present", "message", "caption",
})
doit("john", []string{"token", "present", "message"})
doit("james", []string{})
}
func TestUsernameTaken(t *testing.T) {
var g Group
err := json.Unmarshal([]byte(desc2JSON), &g.description)
if err != nil {
t.Fatalf("unmarshal: %v", err)
}
if g.UserExists("") {
t.Error("UserExists(\"\") is true, expected false")
}
if !g.UserExists("john") {
t.Error("UserExists(john) is false")
}
if !g.UserExists("john") {
t.Error("UserExists(james) is false")
}
if g.UserExists("paul") {
t.Error("UserExists(paul) is true")
}
}
func TestFmtpValue(t *testing.T) {
type fmtpTest struct {
fmtp string
key string
value string
}
fmtpTests := []fmtpTest{
{"", "foo", ""},
{"profile-id=0", "profile-id", "0"},
{"profile-id=0", "foo", ""},
{"level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42001f", "profile-level-id", "42001f"},
{"foo=1;bar=2;quux=3", "foo", "1"},
{"foo=1;bar=2;quux=3", "bar", "2"},
{"foo=1;bar=2;quux=3", "fu", ""},
}
for _, test := range fmtpTests {
v := fmtpValue(test.fmtp, test.key)
if v != test.value {
t.Errorf("fmtpValue(%v, %v) = %v, expected %v",
test.fmtp, test.key, v, test.value,
)
}
}
}
func TestValidGroupName(t *testing.T) {
type nameTest struct {
name string
result bool
}
tests := []nameTest{
{"", false},
{"/", false},
{"/foo", false},
{"foo/", false},
{"./foo", false},
{"foo/.", false},
{"../foo", false},
{"foo/..", false},
{"foo/./bar", false},
{"foo/../bar", false},
{"foo", true},
{"foo/bar", true},
}
for _, test := range tests {
r := validGroupName(test.name)
if r != test.result {
t.Errorf("Valid %v: got %v, expected %v",
test.name, r, test.result)
}
}
}