func TestListPlayerMatchStat(t *testing.T) {
store := test.GetStore(t)
db := store.Conn()
defer db.Close()
CreateSchema(store)
NewPlayerMatchStat(store, PlayerMatchStat{
Score: 1,
AliasID: 1,
MatchID: 2,
})
NewPlayerMatchStat(store, PlayerMatchStat{
Score: -1,
AliasID: 2,
MatchID: 2,
})
NewPlayerMatchStat(store, PlayerMatchStat{
Score: -1,
AliasID: 2,
MatchID: 1,
})
pls := ListPlayerMatchStat(store, 2)
assert.Len(t, pls, 2)
pls = ListPlayerMatchStat(store, 1)
assert.Len(t, pls, 1)
pls = ListPlayerMatchStat(store, 5)
assert.Len(t, pls, 0)
}
func TestListPlayers(t *testing.T) {
store := test.GetStore(t)
db := store.Conn()
defer db.Close()
CreateSchema(store)
NewPlayer(store, "foo", "123")
NewPlayer(store, "bar", "123")
NewPlayer(store, "baz", "123")
players := ListPlayers(store)
assert.Len(t, players, 3)
d := map[string]int{
"foo": 0,
"bar": 0,
"baz": 0,
}
for _, p := range players {
d[p.Name] = 1
}
for k, v := range d {
if v != 1 {
t.Fatalf("player %s not seen", k)
}
}
}
func TestNewPlayerMatchStat(t *testing.T) {
store := test.GetStore(t)
db := store.Conn()
defer db.Close()
CreateSchema(store)
pms := PlayerMatchStat{
Score: 10,
Kills: 10,
AliasID: 2,
MatchID: 3,
}
pmsid := NewPlayerMatchStat(store, pms)
var fpms PlayerMatchStat
nf := db.Find(&fpms, pmsid).RecordNotFound()
assert.False(t, nf, "expected to find player-match stat of ID %u", pmsid)
assert.Equal(t, pms.AliasID, fpms.AliasID)
assert.Equal(t, pms.MatchID, fpms.MatchID)
assert.Equal(t, pms.Score, fpms.Score)
}
func TestNewAlias(t *testing.T) {
store := test.GetStore(t)
db := store.Conn()
defer db.Close()
CreateSchema(store)
// add bogus alias first
aidfoo := NewAliasOrCurrent(store, Alias{Alias: "foo"})
// now the one we're going to track
aidbar := NewAliasOrCurrent(store, Alias{Alias: "bar"})
if aidfoo == aidbar {
t.Fatalf("expected IDs to be different, got %u %u",
aidfoo, aidbar)
}
// try again, we should get the same alias
aidbar2 := NewAliasOrCurrent(store, Alias{Alias: "bar"})
if aidbar2 != aidbar {
t.Fatalf("expected the same ID, got %u %u",
aidbar, aidbar2)
}
}
func TestHasPlayer(t *testing.T) {
store := test.GetStore(t)
db := store.Conn()
defer db.Close()
CreateSchema(store)
NewPlayer(store, "foo", "123")
assert.True(t, HasPlayer(store, "foo"))
assert.False(t, HasPlayer(store, "bar"))
}
func TestGetAlias(t *testing.T) {
store := test.GetStore(t)
db := store.Conn()
defer db.Close()
CreateSchema(store)
// add bogus alias first
aidfoo := NewAliasOrCurrent(store, Alias{Alias: "foo"})
afoo := GetAlias(store, aidfoo)
assert.NotNil(t, afoo)
assert.Nil(t, GetAlias(store, 999))
}
func TestGetPlayer(t *testing.T) {
store := test.GetStore(t)
db := store.Conn()
defer db.Close()
CreateSchema(store)
pid1 := NewPlayer(store, "foo", "123")
p := GetPlayer(store, pid1)
assert.Equal(t, "foo", p.Name)
assert.Equal(t, "123", p.PasswordHash)
assert.Equal(t, pid1, p.ID)
}
func TestPlayer(t *testing.T) {
store := test.GetStore(t)
db := store.Conn()
defer db.Close()
CreateSchema(store)
id := NewPlayer(store, "foo", "123")
var p Player
nf := db.First(&p, id).RecordNotFound()
assert.False(t, nf)
assert.Equal(t, "foo", p.Name)
assert.Equal(t, "123", p.PasswordHash)
}
func TestListItemStat(t *testing.T) {
store := test.GetStore(t)
db := store.Conn()
defer db.Close()
CreateSchema(store)
is := ItemStat{
Type: MegaHealth,
Pickups: 1,
PlayerMatchStatID: 2,
}
NewItemStat(store, is)
iss := ListItemStats(store, 2)
assert.Len(t, iss, 1)
assert.Len(t, ListItemStats(store, 9999), 0)
}
func TestClaimAlias(t *testing.T) {
store := test.GetStore(t)
db := store.Conn()
defer db.Close()
CreateSchema(store)
db.Create(&Alias{Alias: "foo"})
db.Create(&Alias{Alias: "bar"})
db.Create(&Alias{Alias: "baz"})
ClaimAliasesByPlayer(store, 1, []string{"foo", "bar"})
player1_aliases := GetAliases(store, 1)
if len(player1_aliases) != 2 {
t.Fatalf("expected 2 aliases, got %u",
len(player1_aliases))
}
for _, a := range player1_aliases {
if a.Alias != "foo" && a.Alias != "bar" {
t.Fatalf("unexpected alias: %s", a.Alias)
}
if a.PlayerID != 1 {
t.Fatalf("alias with incorrect player ID %u",
a.PlayerID)
}
}
unclaimed := GetAliases(store, NoUser)
if len(unclaimed) != 1 {
t.Fatal("expected 1 unclaimed alias, got %u",
len(unclaimed))
}
ua := unclaimed[0]
if ua.Alias != "baz" {
t.Fatalf("expected 'baz' to be unclaimed, got %s",
ua.Alias)
}
}
func TestListWeaponStat(t *testing.T) {
store := test.GetStore(t)
db := store.Conn()
defer db.Close()
CreateSchema(store)
w := WeaponStat{
Hits: 10,
Shots: 100,
PlayerMatchStatID: 2,
}
NewWeaponStat(store, w)
wfs := ListWeaponStats(store, 2)
assert.Len(t, wfs, 1)
assert.Len(t, ListWeaponStats(store, 9999), 0)
}
func TestGetAliases(t *testing.T) {
store := test.GetStore(t)
db := store.Conn()
defer db.Close()
CreateSchema(store)
db.Create(&Alias{Alias: "foo"})
db.Create(&Alias{Alias: "bar"})
aliases := GetAliases(store, NoUser)
if len(aliases) != 2 {
t.Fatalf("returned aliases %u expected 2",
len(aliases))
}
// create another one, assigned to player 1
db.Create(&Alias{Alias: "baz", PlayerID: 1})
aliases = GetAliases(store, NoUser)
// still expecting 2
if len(aliases) != 2 {
t.Fatalf("returned aliases %u expected 2",
len(aliases))
}
aliases = GetAliases(store, 1)
// still expecting 2
if len(aliases) != 1 {
t.Fatalf("returned aliases %u expected 1",
len(aliases))
}
al := aliases[0]
if al.Alias != "baz" {
t.Fatalf("expected baz, got %s", al.Alias)
}
}
func TestNewItemStat(t *testing.T) {
store := test.GetStore(t)
db := store.Conn()
defer db.Close()
CreateSchema(store)
is := ItemStat{
Type: MegaHealth,
Pickups: 1,
PlayerMatchStatID: 2,
}
isid := NewItemStat(store, is)
var fis ItemStat
nf := db.Find(&fis, isid).RecordNotFound()
assert.False(t, nf)
assert.Equal(t, is.Type, fis.Type)
assert.Equal(t, is.Pickups, fis.Pickups)
assert.Equal(t, is.PlayerMatchStatID, fis.PlayerMatchStatID)
}
func TestNewWeaponStat(t *testing.T) {
store := test.GetStore(t)
db := store.Conn()
defer db.Close()
CreateSchema(store)
w := WeaponStat{
Hits: 10,
Shots: 100,
PlayerMatchStatID: 2,
}
wid := NewWeaponStat(store, w)
var fw WeaponStat
nf := db.Find(&fw, wid).RecordNotFound()
assert.False(t, nf)
assert.Equal(t, w.Hits, fw.Hits)
assert.Equal(t, w.Shots, fw.Shots)
assert.Equal(t, w.PlayerMatchStatID, fw.PlayerMatchStatID)
}
func TestNewMatchInfo(t *testing.T) {
store := test.GetStore(t)
db := store.Conn()
defer db.Close()
CreateSchema(store)
ws := WeaponStat{
Type: RocketLauncher,
Shots: 10,
Hits: 10,
Kills: 1,
}
is := ItemStat{
Type: MegaHealth,
Pickups: 10,
}
pmsfoo := PlayerMatchStat{
Kills: 10,
Deaths: 10,
Suicides: 1,
Score: -2,
}
pmsbar := PlayerMatchStat{
Kills: 10,
Deaths: 10,
Suicides: 1,
Score: 2,
}
matchtime := time.Now()
t.Logf("time: %v", matchtime.Format(time.RFC822Z))
m := MatchInfo{
Match: Match{
DataHash: "foobar",
Map: "q3dm17",
Duration: 100,
DateTime: matchtime,
},
PlayerData: []PlayerDataItem{
{
Alias{Alias: "foo"},
[]WeaponStat{
ws,
},
[]ItemStat{
is,
},
pmsfoo,
},
{
Alias{Alias: "bar"},
[]WeaponStat{
ws,
},
[]ItemStat{},
pmsbar,
},
},
}
id, hash := NewMatchInfo(store, &m)
assert.Equal(t, "foobar", hash, "should be equal")
match := FindMatchByHash(store, "foobar")
assert.NotNil(t, match)
assert.Equal(t, id, match.ID, "different match ID")
assert.Equal(t, "q3dm17", match.Map, "incorrect map")
assert.Equal(t, uint(100), match.Duration, "incorrect duration")
assert.Equal(t, matchtime.Format(time.RFC822Z),
match.DateTime.Format(time.RFC822Z), "incorrect match datetime")
aliases := GetAliases(store, NoUser)
assert.Len(t, aliases, 2)
var afooid, abarid uint
for _, a := range aliases {
if a.Alias != "foo" && a.Alias != "bar" {
assert.Fail(t, "unexpected alias: %s", a.Alias)
}
if a.Alias == "foo" {
afooid = a.ID
} else if a.Alias == "bar" {
abarid = a.ID
}
}
// find player match stats for this match
pms := ListPlayerMatchStat(store, id)
assert.Len(t, pms, 2)
for _, p := range pms {
if p.AliasID == afooid {
// player foo
// 1 weapon stat
// 1 item stats
assert.Equal(t, pmsfoo.Kills, p.Kills)
assert.Len(t, ListWeaponStats(store, p.ID), 1)
assert.Len(t, ListItemStats(store, p.ID), 1)
} else if p.AliasID == abarid {
// player bar
// 1 weapon stat
// 0 item stats
assert.Equal(t, pmsbar.Kills, p.Kills)
assert.Len(t, ListWeaponStats(store, p.ID), 1)
assert.Len(t, ListItemStats(store, p.ID), 0)
}
}
}
func TestGetMatchinfo(t *testing.T) {
store := test.GetStore(t)
db := store.Conn()
defer db.Close()
CreateSchema(store)
m := GetMatchInfo(store, "fooo")
assert.Nil(t, m)
// start with match
mid := NewMatch(store, Match{
DataHash: "foobar",
Map: "q3dm17",
Duration: 100,
})
// alias foo
aidfoo := NewAliasOrCurrent(store, Alias{
Alias: "foo",
})
// match stats for foo
pmsfoo := NewPlayerMatchStat(store, PlayerMatchStat{
Score: 1,
Kills: 2,
Suicides: 1,
AliasID: aidfoo,
MatchID: mid,
})
// weapon stats for foo's stats in match
NewWeaponStat(store, WeaponStat{
Type: RocketLauncher,
Shots: 1,
PlayerMatchStatID: pmsfoo,
})
// item stats for foo's stats in match
NewItemStat(store, ItemStat{
Type: MegaHealth,
Pickups: 1,
PlayerMatchStatID: pmsfoo,
})
aidbar := NewAliasOrCurrent(store, Alias{
Alias: "bar",
})
pmsbar := NewPlayerMatchStat(store, PlayerMatchStat{
Score: -2,
Kills: 2,
Suicides: 1,
AliasID: aidbar,
MatchID: mid,
})
NewWeaponStat(store, WeaponStat{
Type: Plasmagun,
Shots: 10,
PlayerMatchStatID: pmsbar,
})
mi := GetMatchInfo(store, "foobar")
assert.NotNil(t, mi)
assert.Equal(t, "q3dm17", mi.Match.Map)
assert.Equal(t, "foobar", mi.Match.DataHash)
assert.Equal(t, uint(100), mi.Match.Duration)
assert.Len(t, mi.PlayerData, 2)
for _, p := range mi.PlayerData {
if p.Alias.Alias == "foo" {
assert.Equal(t, 1, p.Stats.Score)
assert.Equal(t, aidfoo, p.Stats.AliasID)
assert.Equal(t, mid, p.Stats.MatchID)
assert.Len(t, p.Weapons, 1)
assert.Len(t, p.Items, 1)
w := p.Weapons[0]
assert.Equal(t, RocketLauncher, w.Type)
assert.Equal(t, uint(1), w.Shots)
assert.Equal(t, pmsfoo, w.PlayerMatchStatID)
i := p.Items[0]
assert.Equal(t, MegaHealth, i.Type)
assert.Equal(t, uint(1), i.Pickups)
assert.Equal(t, pmsfoo, i.PlayerMatchStatID)
} else if p.Alias.Alias == "bar" {
assert.Len(t, p.Weapons, 1)
assert.Len(t, p.Items, 0)
} else {
assert.Fail(t, "unexpected alias: %s",
p.Alias.Alias)
}
}
}
func TestGetPlayerGlobalStats(t *testing.T) {
store := test.GetStore(t)
db := store.Conn()
defer db.Close()
CreateSchema(store)
m1 := NewMatch(store, Match{Map: "q3dm17", Duration: 10})
m2 := NewMatch(store, Match{Map: "q3dm4", Duration: 100})
a1 := NewAliasOrCurrent(store, Alias{Alias: "foo"})
p1 := NewPlayer(store, "fooplayer", "")
// claim aliases
ClaimAliasesByPlayer(store, p1, []string{"foo"})
pms1 := NewPlayerMatchStat(store, PlayerMatchStat{
Score: 10,
Kills: 12,
Deaths: 33,
Suicides: 2,
MatchID: m1,
AliasID: a1,
})
NewWeaponStat(store, WeaponStat{
Type: RocketLauncher,
Shots: 100,
Hits: 10,
PlayerMatchStatID: pms1,
})
NewWeaponStat(store, WeaponStat{
Type: GrenadeLauncher,
Shots: 25,
Hits: 5,
PlayerMatchStatID: pms1,
})
NewItemStat(store, ItemStat{
Type: MegaHealth,
Pickups: 12,
PlayerMatchStatID: pms1,
})
NewItemStat(store, ItemStat{
Type: RedArmor,
Pickups: 5,
PlayerMatchStatID: pms1,
})
NewItemStat(store, ItemStat{
Type: QuadDamage,
Pickups: 5,
Time: time.Duration(30) * time.Second,
PlayerMatchStatID: pms1,
})
pms2 := NewPlayerMatchStat(store, PlayerMatchStat{
Score: 5,
Kills: 5,
Deaths: 3,
Suicides: 2,
MatchID: m2,
AliasID: a1,
})
NewWeaponStat(store, WeaponStat{
Type: RocketLauncher,
Shots: 10,
Hits: 5,
PlayerMatchStatID: pms2,
})
NewWeaponStat(store, WeaponStat{
Type: Shotgun,
Shots: 10,
Hits: 5,
PlayerMatchStatID: pms2,
})
NewItemStat(store, ItemStat{
Type: GreenArmor,
Pickups: 3,
PlayerMatchStatID: pms2,
})
NewItemStat(store, ItemStat{
Type: QuadDamage,
Pickups: 1,
Time: time.Duration(5) * time.Second,
PlayerMatchStatID: pms2,
})
pgs := GetPlayerGlobaStats(store, p1)
assert.Equal(t, uint(12+5), pgs.Kills)
assert.Equal(t, uint(2+2), pgs.Suicides)
assert.Equal(t, uint(33+3), pgs.Deaths)
assert.Equal(t, uint(2), pgs.Matches)
assert.Len(t, pgs.Weapons, 3)
assert.Len(t, pgs.Items, 4)
// these should be aggregate values from all weapons
for _, w := range pgs.Weapons {
switch w.Type {
case RocketLauncher:
assert.Equal(t, uint(110), w.Shots)
assert.Equal(t, uint(15), w.Hits)
case GrenadeLauncher:
assert.Equal(t, uint(25), w.Shots)
case Shotgun:
assert.Equal(t, uint(10), w.Shots)
assert.Equal(t, uint(5), w.Hits)
default:
assert.Fail(t, "unexpected weapon type: %s", w.Type)
}
}
// aggregate values for all items
for _, i := range pgs.Items {
switch i.Type {
case MegaHealth:
assert.Equal(t, uint(12), i.Pickups)
case RedArmor:
assert.Equal(t, uint(5), i.Pickups)
case GreenArmor:
assert.Equal(t, uint(3), i.Pickups)
case QuadDamage:
assert.Equal(t, uint(5+1), i.Pickups)
assert.Equal(t, time.Duration(30+5)*time.Second,
i.Time)
}
}
}