Merge pull request #206 from markus-wa/improve-codecov

v2: unit tests and cleanup

Author: markus-wa

pkg/demoinfocs/common/common_test.go

@@ -188,7 +188,7 @@ func entityWithProperty(propName string, value st.PropertyValue) *stfake.Entity
 	prop.On("Value").Return(value)
 
 	entity.On("Property", propName).Return(prop)
-	entity.On("PropertyValue", propName).Return(prop, true)
+	entity.On("PropertyValue", propName).Return(value, true)
 	entity.On("PropertyValueMust", propName).Return(value)
 
 	return entity

pkg/demoinfocs/common/entity_util_test.go

@@ -0,0 +1,23 @@
+package common
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestGetFloat_Nil(t *testing.T) {
+	assert.Zero(t, getFloat(nil, "test"))
+}
+
+func TestGetInt_Nil(t *testing.T) {
+	assert.Zero(t, getInt(nil, "test"))
+}
+
+func TestGetString_Nil(t *testing.T) {
+	assert.Empty(t, getString(nil, "test"))
+}
+
+func TestGetBool_Nil(t *testing.T) {
+	assert.Empty(t, getBool(nil, "test"))
+}

pkg/demoinfocs/common/equipment.go

@@ -273,9 +273,9 @@ func MapEquipment(eqName string) EquipmentType {
 type ZoomLevel int
 
 const (
-	ZoomNone = 0
-	ZoomHalf = 1
-	ZoomFull = 2
+	ZoomNone ZoomLevel = 0
+	ZoomHalf ZoomLevel = 1
+	ZoomFull ZoomLevel = 2
 )
 
 // Equipment is a weapon / piece of equipment belonging to a player.
@@ -315,12 +315,17 @@ func (e Equipment) AmmoInMagazine() int {
 		return 1
 	}
 
+	if e.Entity == nil {
+		return 0
+	}
+
 	val, ok := e.Entity.PropertyValue("m_iClip1")
 	if !ok {
 		return -1
 	}
 
-	return val.IntVal
+	// need to subtract 1 as m_iClip1 is nrOfBullets + 1
+	return val.IntVal - 1
 }
 
 // AmmoType returns the weapon's ammo type, mostly (only?) relevant for grenades.
@@ -354,6 +359,10 @@ func (e Equipment) AmmoReserve() int {
 		return 0
 	}
 
+	if e.Entity == nil {
+		return 0
+	}
+
 	// if the property doesn't exist we return 0 by default
 	val, _ := e.Entity.PropertyValue("m_iPrimaryReserveAmmoCount")
 

pkg/demoinfocs/common/equipment_test.go

@@ -38,6 +38,29 @@ func TestEquipment_UniqueID(t *testing.T) {
 	assert.NotEqual(t, NewEquipment(EqAK47).UniqueID(), NewEquipment(EqAK47).UniqueID(), "UniqueIDs of different equipment instances should be different")
 }
 
+func TestEquipment_AmmoInMagazine(t *testing.T) {
+	wep := &Equipment{
+		Type:   EqAK47,
+		Entity: entityWithProperty("m_iClip1", st.PropertyValue{IntVal: 31}),
+	}
+
+	// returned value should be minus 1, m_iClip1 is always 1 more than the actual number of bullets
+	assert.Equal(t, 30, wep.AmmoInMagazine())
+}
+
+func TestEquipment_AmmoInMagazine_NotFound(t *testing.T) {
+	entity := entityWithID(1)
+	entity.On("PropertyValue", "m_iClip1").Return(st.PropertyValue{}, false)
+
+	wep := &Equipment{
+		Type:   EqAK47,
+		Entity: entity,
+	}
+
+	// returned value should be minus 1, m_iClip1 is always 1 more than the actual number of bullets
+	assert.Equal(t, -1, wep.AmmoInMagazine())
+}
+
 func TestEquipment_AmmoInMagazine_Grenade(t *testing.T) {
 	wep := &Equipment{
 		Type: EqFlash,
@@ -46,6 +69,24 @@ func TestEquipment_AmmoInMagazine_Grenade(t *testing.T) {
 	assert.Equal(t, 1, wep.AmmoInMagazine())
 }
 
+func TestEquipment_AmmoInMagazine_EntityNil(t *testing.T) {
+	wep := &Equipment{
+		Type: EqAK47,
+	}
+
+	assert.Equal(t, 0, wep.AmmoInMagazine())
+}
+
+func TestEquipment_AmmoReserve(t *testing.T) {
+	entity := entityWithProperty("m_iPrimaryReserveAmmoCount", st.PropertyValue{IntVal: 60})
+	wep := &Equipment{
+		Type:   EqAK47,
+		Entity: entity,
+	}
+
+	assert.Equal(t, 60, wep.AmmoReserve())
+}
+
 func TestEquipment_AmmoReserve_Grenade(t *testing.T) {
 	owner := new(Player)
 	owner.AmmoLeft[1] = 2
@@ -60,14 +101,39 @@ func TestEquipment_AmmoReserve_Grenade(t *testing.T) {
 	assert.Equal(t, 1, wep.AmmoReserve())
 }
 
-func TestEquipment_AmmoReserve2_Grenade_OwnerNil(t *testing.T) {
+func TestEquipment_AmmoReserve_Grenade_OwnerNil(t *testing.T) {
 	wep := &Equipment{
 		Type: EqFlash,
 	}
 
 	assert.Equal(t, 0, wep.AmmoReserve())
 }
 
+func TestEquipment_AmmoReserve_EntityNil(t *testing.T) {
+	wep := &Equipment{
+		Type: EqAK47,
+	}
+
+	assert.Equal(t, 0, wep.AmmoReserve())
+}
+
+func TestEquipment_ZoomLevel(t *testing.T) {
+	wep := &Equipment{
+		Type:   EqAK47,
+		Entity: entityWithProperty("m_zoomLevel", st.PropertyValue{IntVal: 2}),
+	}
+
+	assert.Equal(t, ZoomFull, wep.ZoomLevel())
+}
+
+func TestEquipment_ZoomLevel_EntityNil(t *testing.T) {
+	wep := &Equipment{
+		Type: EqAK47,
+	}
+
+	assert.Equal(t, ZoomLevel(0), wep.ZoomLevel())
+}
+
 func TestEquipmentAlternative(t *testing.T) {
 	assert.Equal(t, EqUSP, EquipmentAlternative(EqP2000))
 	assert.Equal(t, EqCZ, EquipmentAlternative(EqP250))

pkg/demoinfocs/common/player.go

@@ -278,9 +278,9 @@ func (p *Player) Velocity() r3.Vector {
 	}
 
 	return r3.Vector{
-		X: p.Entity.PropertyValueMust("localdata.m_vecVelocity[0]").Float64Val(),
-		Y: p.Entity.PropertyValueMust("localdata.m_vecVelocity[1]").Float64Val(),
-		Z: p.Entity.PropertyValueMust("localdata.m_vecVelocity[2]").Float64Val(),
+		X: float64(p.Entity.PropertyValueMust("localdata.m_vecVelocity[0]").FloatVal),
+		Y: float64(p.Entity.PropertyValueMust("localdata.m_vecVelocity[1]").FloatVal),
+		Z: float64(p.Entity.PropertyValueMust("localdata.m_vecVelocity[2]").FloatVal),
 	}
 }
 

pkg/demoinfocs/common/player_test.go

@@ -4,9 +4,11 @@ import (
 	"testing"
 	"time"
 
+	"github.com/golang/geo/r3"
 	"github.com/stretchr/testify/assert"
 
 	st "github.com/markus-wa/demoinfocs-golang/v2/pkg/demoinfocs/sendtables"
+	stfake "github.com/markus-wa/demoinfocs-golang/v2/pkg/demoinfocs/sendtables/fake"
 )
 
 func TestPlayerActiveWeapon(t *testing.T) {
@@ -206,6 +208,36 @@ func TestPlayer_IsAirborne(t *testing.T) {
 	assert.True(t, pl.IsAirborne())
 }
 
+func TestPlayer_IsDucking(t *testing.T) {
+	pl := playerWithProperty("localdata.m_Local.m_bDucking", st.PropertyValue{IntVal: 0})
+
+	assert.False(t, pl.IsDucking())
+
+	pl = playerWithProperty("localdata.m_Local.m_bDucking", st.PropertyValue{IntVal: 1})
+
+	assert.True(t, pl.IsDucking())
+}
+
+func TestPlayer_HasDefuseKit(t *testing.T) {
+	pl := playerWithProperty("m_bHasDefuser", st.PropertyValue{IntVal: 0})
+
+	assert.False(t, pl.HasDefuseKit())
+
+	pl = playerWithProperty("m_bHasDefuser", st.PropertyValue{IntVal: 1})
+
+	assert.True(t, pl.HasDefuseKit())
+}
+
+func TestPlayer_HasHelmet(t *testing.T) {
+	pl := playerWithProperty("m_bHasHelmet", st.PropertyValue{IntVal: 0})
+
+	assert.False(t, pl.HasHelmet())
+
+	pl = playerWithProperty("m_bHasHelmet", st.PropertyValue{IntVal: 1})
+
+	assert.True(t, pl.HasHelmet())
+}
+
 func TestPlayer_IsControllingBot_NilEntity(t *testing.T) {
 	pl := new(Player)
 
@@ -250,6 +282,107 @@ func TestPlayer_ControlledBot(t *testing.T) {
 	assert.Same(t, dave, pl.ControlledBot())
 }
 
+func TestPlayer_Armor(t *testing.T) {
+	pl := playerWithProperty("m_ArmorValue", st.PropertyValue{IntVal: 95})
+
+	assert.Equal(t, 95, pl.Armor())
+}
+
+func TestPlayer_Money(t *testing.T) {
+	pl := playerWithProperty("m_iAccount", st.PropertyValue{IntVal: 800})
+
+	assert.Equal(t, 800, pl.Money())
+}
+
+func TestPlayer_ViewDirectionX(t *testing.T) {
+	pl := playerWithProperty("m_angEyeAngles[1]", st.PropertyValue{FloatVal: 180})
+
+	assert.Equal(t, float32(180), pl.ViewDirectionX())
+}
+
+func TestPlayer_ViewDirectionY(t *testing.T) {
+	pl := playerWithProperty("m_angEyeAngles[0]", st.PropertyValue{FloatVal: 15})
+
+	assert.Equal(t, float32(15), pl.ViewDirectionY())
+}
+
+func TestPlayer_Position(t *testing.T) {
+	entity := new(stfake.Entity)
+	pos := r3.Vector{X: 1, Y: 2, Z: 3}
+
+	entity.On("Position").Return(pos)
+
+	pl := &Player{Entity: entity}
+
+	assert.Equal(t, pos, pl.Position())
+}
+
+func TestPlayer_Position_EntityNil(t *testing.T) {
+	pl := new(Player)
+
+	assert.Empty(t, pl.Position())
+}
+
+func TestPlayer_Velocity(t *testing.T) {
+	entity := new(stfake.Entity)
+	entity.On("PropertyValueMust", "localdata.m_vecVelocity[0]").Return(st.PropertyValue{FloatVal: 1})
+	entity.On("PropertyValueMust", "localdata.m_vecVelocity[1]").Return(st.PropertyValue{FloatVal: 2})
+	entity.On("PropertyValueMust", "localdata.m_vecVelocity[2]").Return(st.PropertyValue{FloatVal: 3})
+
+	pl := &Player{Entity: entity}
+
+	expected := r3.Vector{X: 1, Y: 2, Z: 3}
+	assert.Equal(t, expected, pl.Velocity())
+}
+
+func TestPlayer_Velocity_EntityNil(t *testing.T) {
+	pl := new(Player)
+
+	assert.Empty(t, pl.Velocity())
+}
+
+func TestPlayer_ClanTag(t *testing.T) {
+	pl := playerWithResourceProperty("m_szClan", st.PropertyValue{StringVal: "SuperClan"})
+
+	assert.Equal(t, "SuperClan", pl.ClanTag())
+}
+
+func TestPlayer_Ping(t *testing.T) {
+	pl := playerWithResourceProperty("m_iPing", st.PropertyValue{IntVal: 45})
+
+	assert.Equal(t, 45, pl.Ping())
+}
+
+func TestPlayer_Score(t *testing.T) {
+	pl := playerWithResourceProperty("m_iScore", st.PropertyValue{IntVal: 10})
+
+	assert.Equal(t, 10, pl.Score())
+}
+
+func TestPlayer_Kills(t *testing.T) {
+	pl := playerWithResourceProperty("m_iKills", st.PropertyValue{IntVal: 5})
+
+	assert.Equal(t, 5, pl.Kills())
+}
+
+func TestPlayer_Deaths(t *testing.T) {
+	pl := playerWithResourceProperty("m_iDeaths", st.PropertyValue{IntVal: 2})
+
+	assert.Equal(t, 2, pl.Deaths())
+}
+
+func TestPlayer_Assists(t *testing.T) {
+	pl := playerWithResourceProperty("m_iAssists", st.PropertyValue{IntVal: 3})
+
+	assert.Equal(t, 3, pl.Assists())
+}
+
+func TestPlayer_MVPs(t *testing.T) {
+	pl := playerWithResourceProperty("m_iMVPs", st.PropertyValue{IntVal: 4})
+
+	assert.Equal(t, 4, pl.MVPs())
+}
+
 func TestPlayer_SteamID32(t *testing.T) {
 	pl := &Player{SteamID64: 76561198012952267}
 
@@ -263,3 +396,12 @@ func newPlayer(tick int) *Player {
 func playerWithProperty(propName string, value st.PropertyValue) *Player {
 	return &Player{Entity: entityWithProperty(propName, value)}
 }
+
+func playerWithResourceProperty(propName string, value st.PropertyValue) *Player {
+	return &Player{
+		EntityID: 1,
+		demoInfoProvider: demoInfoProviderMock{
+			playerResourceEntity: entityWithProperty(propName+".001", value),
+		},
+	}
+}

pkg/demoinfocs/datatables.go

@@ -527,6 +527,7 @@ func (p *parser) infernoExpired(inf *common.Inferno) {
 	p.gameEventHandler.deleteThrownGrenade(inf.Thrower(), common.EqIncendiary)
 }
 
+//nolint:funlen
 func (p *parser) bindGameRules() {
 	grPrefix := func(s string) string {
 		return fmt.Sprintf("%s.%s", gameRulesPrefix, s)

pkg/demoinfocs/sendtables/entity.go

@@ -42,7 +42,12 @@ func (e *entity) Properties() (out []Property) {
 }
 
 func (e *entity) property(name string) *property {
-	return &e.props[e.serverClass.propNameToIndex[name]]
+	i, ok := e.serverClass.propNameToIndex[name]
+	if !ok {
+		return nil
+	}
+
+	return &e.props[i]
 }
 
 // Property finds a property on the entity by name.
@@ -271,16 +276,6 @@ func (e *entity) OnPositionUpdate(h func(pos r3.Vector)) {
 	}
 }
 
-// BindPosition binds the entity's position to a pointer variable.
-// The pointer is updated every time a position-relevant property is updated.
-//
-// See also OnPositionUpdate()
-func (e *entity) BindPosition(pos *r3.Vector) {
-	e.OnPositionUpdate(func(newPos r3.Vector) {
-		*pos = newPos
-	})
-}
-
 // Returns a coordinate from a cell + offset
 func coordFromCell(cell, cellWidth int, offset float64) float64 {
 	return float64(cell*cellWidth-maxCoordInt) + offset