d378759d58
* add a new "pipeline" concept - added new Pipeline type which is a series of stages - added a global registry to facilitate plugin architecture - 100% test coverage * Refactor rulesets to provide and use Pipeline * fix copypasta comments * fix lint for unused method * include game over stages in ruleset pipelines * clean up unused private standard methods * remove unused private methods in squad ruleset * remove unused private methods in royale ruleset * refactor: pipeline clone + return next board state * YAGNI: remove unused Append * refactor: improve stage names * add no-op behavior to stages for initial state * refactor: no-op decision within stage functions * remove misleading comment that isn't true * dont bother checking for init in gameover stages * remove redundant test * refactor: provide a combined ruleset/pipeline type * fix: movement no-op for GameOver check IsGameOver needs to run pipeline, move snakes needs to no-op for that * add test coverage * refactor: improve stage names and use constants * add Error method Support error checking before calling Execute() * update naming to be American style * panic when overwriting stages in global registry * rename "Error" method and improve docs * use testify lib for panic assertion * remove redundant food stage * use ruleset-specific logic for game over checks * re-work Pipeline errors * rework errors again * add defensive check for zero length snake * use old logic which checks current state, not next * add warning about how PipelineRuleset checks for game over
91 lines
3.2 KiB
Go
91 lines
3.2 KiB
Go
package rules_test
|
|
|
|
import (
|
|
"errors"
|
|
"testing"
|
|
|
|
"github.com/BattlesnakeOfficial/rules"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func TestPipeline(t *testing.T) {
|
|
r := rules.StageRegistry{}
|
|
|
|
// test empty registry error
|
|
p := rules.NewPipelineFromRegistry(r)
|
|
require.Equal(t, rules.ErrorEmptyRegistry, p.Err())
|
|
_, _, err := p.Execute(nil, rules.Settings{}, nil)
|
|
require.Equal(t, rules.ErrorEmptyRegistry, err)
|
|
|
|
// test empty stages names error
|
|
r.RegisterPipelineStage("astage", mockStageFn(false, nil))
|
|
p = rules.NewPipelineFromRegistry(r)
|
|
require.Equal(t, rules.ErrorNoStages, p.Err())
|
|
_, _, err = p.Execute(&rules.BoardState{}, rules.Settings{}, nil)
|
|
require.Equal(t, rules.ErrorNoStages, err)
|
|
|
|
// test that an unregistered stage name errors
|
|
p = rules.NewPipelineFromRegistry(r, "doesntexist")
|
|
_, _, err = p.Execute(&rules.BoardState{}, rules.Settings{}, nil)
|
|
require.Equal(t, rules.ErrorStageNotFound, p.Err())
|
|
require.Equal(t, rules.ErrorStageNotFound, err)
|
|
|
|
// simplest case - one stage
|
|
ended, next, err := rules.NewPipelineFromRegistry(r, "astage").Execute(&rules.BoardState{}, rules.Settings{}, nil)
|
|
require.NoError(t, err)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, next)
|
|
require.False(t, ended)
|
|
|
|
// test that the pipeline short-circuits for a stage that errors
|
|
r.RegisterPipelineStage("errors", mockStageFn(false, errors.New("")))
|
|
ended, next, err = rules.NewPipelineFromRegistry(r, "errors", "astage").Execute(&rules.BoardState{}, rules.Settings{}, nil)
|
|
require.Error(t, err)
|
|
require.NotNil(t, next)
|
|
require.False(t, ended)
|
|
|
|
// test that the pipeline short-circuits for a stage that ends
|
|
r.RegisterPipelineStage("ends", mockStageFn(true, nil))
|
|
ended, next, err = rules.NewPipelineFromRegistry(r, "ends", "astage").Execute(&rules.BoardState{}, rules.Settings{}, nil)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, next)
|
|
require.True(t, ended)
|
|
|
|
// test that the pipeline runs normally for multiple stages
|
|
ended, next, err = rules.NewPipelineFromRegistry(r, "astage", "ends").Execute(&rules.BoardState{}, rules.Settings{}, nil)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, next)
|
|
require.True(t, ended)
|
|
}
|
|
|
|
func TestStageRegistry(t *testing.T) {
|
|
sr := rules.StageRegistry{}
|
|
|
|
// register a stage without error
|
|
require.NoError(t, sr.RegisterPipelineStageError("test", mockStageFn(false, nil)))
|
|
require.Contains(t, sr, "test")
|
|
|
|
// error on duplicate
|
|
var e rules.RulesetError
|
|
err := sr.RegisterPipelineStageError("test", mockStageFn(false, nil))
|
|
require.Error(t, err)
|
|
require.True(t, errors.As(err, &e), "error should be a RulesetError")
|
|
require.Equal(t, "stage 'test' has already been registered", err.Error())
|
|
|
|
// register another stage with no error
|
|
require.NoError(t, sr.RegisterPipelineStageError("other", mockStageFn(false, nil)))
|
|
require.Contains(t, sr, "other")
|
|
|
|
// register stage
|
|
sr.RegisterPipelineStage("last", mockStageFn(false, nil))
|
|
require.Contains(t, sr, "last")
|
|
|
|
// register existing stage (should just be okay and not panic or anything)
|
|
sr.RegisterPipelineStage("test", mockStageFn(false, nil))
|
|
}
|
|
|
|
func mockStageFn(ended bool, err error) rules.StageFunc {
|
|
return func(b *rules.BoardState, settings rules.Settings, moves []rules.SnakeMove) (bool, error) {
|
|
return ended, err
|
|
}
|
|
}
|