[test] Add more tests for ball placement procedure

Author: g3force

internal/app/config/division.go

@@ -6,3 +6,16 @@ const (
 	DivA Division = "DivA"
 	DivB Division = "DivB"
 )
+
+// Division contain all known command enum constants
+var Divisions = []Division{DivA, DivB}
+
+// Valid checks if the Division enum value is among the known values
+func (g Division) Valid() bool {
+	for _, division := range Divisions {
+		if division == g {
+			return true
+		}
+	}
+	return false
+}

internal/app/controller/engine_test.go

@@ -3,6 +3,7 @@ package controller
 import (
 	"github.com/RoboCup-SSL/ssl-game-controller/internal/app/config"
 	"github.com/go-test/deep"
+	"github.com/pkg/errors"
 	"gopkg.in/yaml.v2"
 	"io/ioutil"
 	"log"
@@ -69,7 +70,9 @@ func Test_engine(t *testing.T) {
 	}
 	for _, f := range files {
 		if !f.IsDir() && strings.HasPrefix(f.Name(), "engine_test_") {
-			processTransitionFile(t, f.Name())
+			t.Run(f.Name(), func(t *testing.T) {
+				processTransitionFile(t, f.Name())
+			})
 		}
 	}
 }
@@ -98,13 +101,19 @@ func processTransitionFile(t *testing.T, fileName string) {
 	}
 
 	// apply the initial state to the engine
+	if err := stateTransitions.InitialState.valid(); err != nil {
+		t.Fatal(err)
+	}
 	stateTransitions.InitialState.applyTo(e.State)
 	// initialize the expected state with the current engine state
 	expectedState := e.State.DeepCopy()
 
 	for i, s := range stateTransitions.Transitions {
 
 		if s.Event != nil {
+			if err := s.Event.valid(); err != nil {
+				t.Fatal(err)
+			}
 			if err := e.Process(*s.Event); err != nil {
 				t.Fatalf("Could not process event '%v': %v", *s.Event, err)
 			}
@@ -116,6 +125,9 @@ func processTransitionFile(t *testing.T, fileName string) {
 		}
 
 		if s.ExpectedStateDiff != nil {
+			if err := s.ExpectedStateDiff.valid(); err != nil {
+				t.Fatal(err)
+			}
 			// apply the expected state diff to the expected state
 			s.ExpectedStateDiff.applyTo(&expectedState)
 		}
@@ -136,6 +148,71 @@ func initialTime() time.Time {
 	return ts
 }
 
+func (e *Event) valid() error {
+	if e.Card != nil && !e.Card.ForTeam.Valid() {
+		return errors.Errorf("Event.Card.ForTeam has an invalid value: %v", e.Card.ForTeam)
+	}
+	if e.Command != nil {
+		if e.Command.ForTeam != nil && !e.Command.ForTeam.Valid() {
+			return errors.Errorf("Event.Command.ForTeam has an invalid value: %v", e.Command.ForTeam)
+		}
+		if !e.Command.Type.Valid() {
+			return errors.Errorf("Event.Command.Type has an invalid value: %v", e.Command.Type)
+		}
+	}
+	if e.GameEvent != nil && !e.GameEvent.Type.Valid() {
+		return errors.Errorf("Event.GameEvent.Type has an invalid value: %v", e.GameEvent.Type)
+	}
+	return nil
+}
+
+func (t *TestState) valid() error {
+	if t.Stage != nil && !t.Stage.Valid() {
+		return errors.Errorf("TestState.Stage has an invalid value: %v", t.Stage)
+	}
+	if t.Command != nil && !t.Command.Valid() {
+		return errors.Errorf("TestState.Command has an invalid value: %v", t.Command)
+	}
+	if t.CommandFor != nil && !t.CommandFor.Valid() {
+		return errors.Errorf("TestState.CommandFor has an invalid value: %v", t.CommandFor)
+	}
+	for i, gameEvent := range t.GameEvents {
+		if !gameEvent.Type.Valid() {
+			return errors.Errorf("TestState.GameEvents[%v].Type has an invalid value: %v", i, gameEvent.Type)
+		}
+	}
+	for team := range t.TeamState {
+		if !team.Valid() {
+			return errors.Errorf("TestState.TeamState has an invalid key: %v", team)
+		}
+	}
+	if t.Division != nil && !t.Division.Valid() {
+		return errors.Errorf("TestState.Division has an invalid value: %v", t.Division)
+	}
+	if t.NextCommand != nil && !t.NextCommand.Valid() {
+		return errors.Errorf("TestState.NextCommand has an invalid value: %v", t.NextCommand)
+	}
+	if t.NextCommandFor != nil && !t.NextCommandFor.Valid() {
+		return errors.Errorf("TestState.NextCommandFor has an invalid value: %v", t.NextCommandFor)
+	}
+	if t.GameEventBehavior != nil {
+		for gameEventType, gameEventBehavior := range *t.GameEventBehavior {
+			if !gameEventType.Valid() {
+				return errors.Errorf("TestState.GameEventBehavior has an invalid key: %v", gameEventType)
+			}
+			if !gameEventBehavior.Valid() {
+				return errors.Errorf("TestState.GameEventBehavior[%v] has an invalid value: %v", gameEventType, gameEventBehavior)
+			}
+		}
+	}
+	for _, proposal := range t.GameEventProposals {
+		if !proposal.GameEvent.Type.Valid() {
+			return errors.Errorf("TestState.GameEventProposals.GameEvent.Type has an invalid value: %v", proposal.GameEvent.Type)
+		}
+	}
+	return nil
+}
+
 func (t *TestState) applyTo(s *State) {
 	if t.Stage != nil {
 		s.Stage = *t.Stage
@@ -170,9 +247,8 @@ func (t *TestState) applyTo(s *State) {
 	if t.Division != nil {
 		s.Division = *t.Division
 	}
-	if t.PlacementPos != nil {
-		s.PlacementPos = t.PlacementPos
-	}
+	// special case: always apply placement pos in order to make it resettable
+	s.PlacementPos = t.PlacementPos
 	if t.AutoContinue != nil {
 		s.AutoContinue = *t.AutoContinue
 	}

internal/app/controller/gameEvent.go

@@ -59,6 +59,60 @@ const (
 	GameEventUnsportingBehaviorMajor GameEventType = "unsportingBehaviorMajor"
 )
 
+// GameStates contain all known command enum constants
+var GameEventTypes = []GameEventType{
+	GameEventNone,
+	GameEventPrepared,
+	GameEventNoProgressInGame,
+	GameEventPlacementFailedByTeamInFavor,
+	GameEventPlacementFailedByOpponent,
+	GameEventPlacementSucceeded,
+	GameEventBotSubstitution,
+	GameEventTooManyRobots,
+	GameEventBallLeftFieldTouchLine,
+	GameEventBallLeftFieldGoalLine,
+	GameEventPossibleGoal,
+	GameEventGoal,
+	GameEventIndirectGoal,
+	GameEventChippedGoal,
+	GameEventAimlessKick,
+	GameEventKickTimeout,
+	GameEventKeeperHeldBall,
+	GameEventAttackerDoubleTouchedBall,
+	GameEventAttackerInDefenseArea,
+	GameEventAttackerTouchedKeeper,
+	GameEventBotDribbledBallTooFar,
+	GameEventBotKickedBallTooFast,
+	GameEventAttackerTooCloseToDefenseArea,
+	GameEventBotInterferedPlacement,
+	GameEventBotCrashDrawn,
+	GameEventBotCrashUnique,
+	GameEventBotCrashUniqueSkipped,
+	GameEventBotPushedBot,
+	GameEventBotPushedBotSkipped,
+	GameEventBotHeldBallDeliberately,
+	GameEventBotTippedOver,
+	GameEventBotTooFastInStop,
+	GameEventDefenderTooCloseToKickPoint,
+	GameEventDefenderInDefenseAreaPartially,
+	GameEventDefenderInDefenseArea,
+	GameEventMultipleCards,
+	GameEventMultiplePlacementFailures,
+	GameEventMultipleFouls,
+	GameEventUnsportingBehaviorMinor,
+	GameEventUnsportingBehaviorMajor,
+}
+
+// Valid checks if the GameEventType enum value is among the known values
+func (g GameEventType) Valid() bool {
+	for _, gameState := range GameEventTypes {
+		if gameState == g {
+			return true
+		}
+	}
+	return false
+}
+
 // GameEvent combines the type of a game event with the corresponding detail structures
 type GameEvent struct {
 	Type    GameEventType    `json:"type"`

internal/app/controller/state.go

@@ -65,6 +65,19 @@ func NewTeam(team refproto.Team) Team {
 	return TeamUnknown
 }
 
+// Teams contain all known team enum constants
+var Teams = []Team{TeamYellow, TeamBlue, TeamBoth, TeamUnknown}
+
+// Valid checks if the Team enum value is among the known values
+func (t Team) Valid() bool {
+	for _, team := range Teams {
+		if team == t {
+			return true
+		}
+	}
+	return false
+}
+
 // Stage represents the different stages of a game
 type Stage string
 
@@ -117,6 +130,16 @@ var Stages = []Stage{
 	StagePostGame,
 }
 
+// Valid checks if the Stage enum value is among the known values
+func (s Stage) Valid() bool {
+	for _, stage := range Stages {
+		if stage == s {
+			return true
+		}
+	}
+	return false
+}
+
 func (s Stage) index() (int, error) {
 	for i, v := range Stages {
 		if v == s {
@@ -194,6 +217,31 @@ const (
 	CommandBallPlacement RefCommand = "ballPlacement"
 )
 
+// Commands contain all known command enum constants
+var RefCommands = []RefCommand{
+	CommandUnknown,
+	CommandHalt,
+	CommandStop,
+	CommandNormalStart,
+	CommandForceStart,
+	CommandDirect,
+	CommandIndirect,
+	CommandKickoff,
+	CommandPenalty,
+	CommandTimeout,
+	CommandBallPlacement,
+}
+
+// Valid checks if the RefCommand enum value is among the known values
+func (c RefCommand) Valid() bool {
+	for _, command := range RefCommands {
+		if command == c {
+			return true
+		}
+	}
+	return false
+}
+
 func (c RefCommand) ContinuesGame() bool {
 	switch c {
 	case CommandNormalStart,
@@ -217,6 +265,10 @@ func (c RefCommand) NeedsTeam() bool {
 	}
 }
 
+func (c RefCommand) IsFreeKick() bool {
+	return c == CommandDirect || c == CommandIndirect
+}
+
 // GameState of a game
 type GameState string
 
@@ -237,6 +289,27 @@ const (
 	GameStateBallPlacement GameState = "Ball Placement"
 )
 
+// GameStates contain all known command enum constants
+var GameStates = []GameState{
+	GameStateHalted,
+	GameStateStopped,
+	GameStateRunning,
+	GameStatePreKickoff,
+	GameStatePrePenalty,
+	GameStateTimeout,
+	GameStateBallPlacement,
+}
+
+// Valid checks if the GameState enum value is among the known values
+func (g GameState) Valid() bool {
+	for _, gameState := range GameStates {
+		if gameState == g {
+			return true
+		}
+	}
+	return false
+}
+
 // TeamInfo about a team
 type TeamInfo struct {
 	Name                  string          `json:"name" yaml:"name"`
@@ -270,6 +343,19 @@ const (
 	GameEventBehaviorOff      GameEventBehavior = "off"
 )
 
+// GameEventBehaviors contain all known command enum constants
+var GameEventBehaviors = []GameEventBehavior{GameEventBehaviorOn, GameEventBehaviorMajority, GameEventBehaviorOff}
+
+// Valid checks if the GameEventBehavior enum value is among the known values
+func (b GameEventBehavior) Valid() bool {
+	for _, behavior := range GameEventBehaviors {
+		if behavior == b {
+			return true
+		}
+	}
+	return false
+}
+
 // GameEventProposal holds a proposal for a game event from an autoRef
 type GameEventProposal struct {
 	ProposerId string    `json:"proposerId"`

internal/app/controller/testdata/engine_test_command_placement.yaml

@@ -0,0 +1,21 @@
+initialState:
+  stage: First Half
+  command: stop
+  division: DivA
+  stageTimeLeft: 5m
+transitions:
+  - event:
+      command:
+        type: ballPlacement
+        forTeam: Yellow
+        location:
+          x: 4.2
+          y: -1.5
+    expectedStateDiff:
+      command: ballPlacement
+      commandFor: Yellow
+      placementPos:
+        x: 4.2
+        y: -1.5
+  - tick: 1s # make sure that the stage time is not proceeded
+