chore: refactor structure

2025-11-21 21:40:15 +03:00
parent 126f381b04
commit 269de2184c
72 changed files with 512 additions and 393 deletions
@@ -0,0 +1,22 @@
+package game
+
+import (
+	"github.com/iliadenisov/galaxy/internal/controller"
+	"github.com/iliadenisov/galaxy/internal/model/game"
+)
+
+func JoinEqualGroups(configure func(*controller.Param), race string) (err error) {
+	control(configure, func(c *controller.Ctrl) {
+		c.Execute(func(r controller.Repo, g game.Game) {
+			err = joinEqualGroups(r, g, race)
+		})
+	})
+	return
+}
+
+func joinEqualGroups(r controller.Repo, g game.Game, race string) error {
+	if err := g.JoinEqualGroups(race); err != nil {
+		return err
+	}
+	return r.SaveState(g)
+}
@@ -0,0 +1,17 @@
+package game_test
+
+import (
+	"testing"
+
+	"github.com/iliadenisov/galaxy/internal/controller"
+	"github.com/iliadenisov/galaxy/internal/game"
+	mg "github.com/iliadenisov/galaxy/internal/model/game"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestJoinEqualGroups(t *testing.T) {
+	g(t, func(p func(*controller.Param), g func() mg.Game) {
+		err := game.JoinEqualGroups(p, "race_01")
+		assert.NoError(t, err)
+	})
+}
@@ -0,0 +1,22 @@
+package game
+
+import (
+	"github.com/iliadenisov/galaxy/internal/controller"
+	"github.com/iliadenisov/galaxy/internal/model/game"
+)
+
+func RenamePlanet(configure func(*controller.Param), race string, number int, name string) (err error) {
+	control(configure, func(c *controller.Ctrl) {
+		c.Execute(func(r controller.Repo, g game.Game) {
+			err = renamePlanet(r, g, race, number, name)
+		})
+	})
+	return
+}
+
+func renamePlanet(r controller.Repo, g game.Game, race string, number int, name string) error {
+	if err := g.RenamePlanet(race, number, name); err != nil {
+		return err
+	}
+	return r.SaveState(g)
+}
@@ -0,0 +1,58 @@
+package game_test
+
+import (
+	"slices"
+	"testing"
+
+	"github.com/iliadenisov/galaxy/internal/controller"
+	e "github.com/iliadenisov/galaxy/internal/error"
+
+	"github.com/google/uuid"
+	"github.com/iliadenisov/galaxy/internal/game"
+	mg "github.com/iliadenisov/galaxy/internal/model/game"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestRenamePlanet(t *testing.T) {
+	g(t, func(p func(*controller.Param), g func() mg.Game) {
+		cg := g()
+		var number int
+		var owner uuid.UUID
+		for pl := range cg.Map.Planet {
+			if cg.Map.Planet[pl].Owner != uuid.Nil {
+				number = int(cg.Map.Planet[pl].Number)
+				owner = cg.Map.Planet[pl].Owner
+				break
+			}
+		}
+		var race string
+		for r := range cg.Race {
+			if cg.Race[r].ID == owner {
+				race = cg.Race[r].Name
+				break
+			}
+		}
+		newName := "Some-New-Name"
+		err := game.RenamePlanet(p, race, number, newName)
+		assert.NoError(t, err)
+		cg = g()
+		pi := slices.IndexFunc(cg.Map.Planet, func(pl mg.Planet) bool { return pl.Owner == owner && pl.Number == uint(number) })
+		assert.GreaterOrEqual(t, pi, 0)
+		assert.Equal(t, "Some-New-Name", cg.Map.Planet[pi].Name)
+
+		ri := slices.IndexFunc(cg.Race, func(r mg.Race) bool { return r.Name != race })
+		assert.GreaterOrEqual(t, ri, 0)
+		otherRace := cg.Race[ri].Name
+
+		err = game.RenamePlanet(p, unknownRaceName, number, newName) // TODO: test actual rip race
+		assert.ErrorContains(t, err, e.GenericErrorText(e.ErrInputUnknownRace))
+		err = game.RenamePlanet(p, race, number, "")
+		assert.ErrorContains(t, err, e.GenericErrorText(e.ErrInputEntityTypeNameInvalid))
+		err = game.RenamePlanet(p, race, -1, newName)
+		assert.ErrorContains(t, err, e.GenericErrorText(e.ErrInputPlanetNumber))
+		err = game.RenamePlanet(p, race, 100500, newName)
+		assert.ErrorContains(t, err, e.GenericErrorText(e.ErrInputEntityNotExists))
+		err = game.RenamePlanet(p, otherRace, number, newName)
+		assert.ErrorContains(t, err, e.GenericErrorText(e.ErrInputEntityNotOwned))
+	})
+}
@@ -0,0 +1,22 @@
+package game
+
+import (
+	"github.com/iliadenisov/galaxy/internal/controller"
+	"github.com/iliadenisov/galaxy/internal/model/game"
+)
+
+func PlanetProduction(configure func(*controller.Param), race string, planetNumber int, prodType, subject string) (err error) {
+	control(configure, func(c *controller.Ctrl) {
+		c.Execute(func(r controller.Repo, g game.Game) {
+			err = planetProduction(r, g, race, planetNumber, prodType, subject)
+		})
+	})
+	return
+}
+
+func planetProduction(r controller.Repo, g game.Game, race string, planetNumber int, prodType, subject string) error {
+	if err := g.PlanetProduction(race, planetNumber, prodType, subject); err != nil {
+		return err
+	}
+	return r.SaveState(g)
+}
@@ -0,0 +1,38 @@
+package game
+
+import (
+	"github.com/iliadenisov/galaxy/internal/controller"
+	"github.com/iliadenisov/galaxy/internal/model/game"
+)
+
+func CreateScience(configure func(*controller.Param), race, typeName string, drive, weapons, shields, cargo float64) (err error) {
+	control(configure, func(c *controller.Ctrl) {
+		c.Execute(func(r controller.Repo, g game.Game) {
+			err = createScience(r, g, race, typeName, drive, weapons, shields, cargo)
+		})
+	})
+	return
+}
+
+func createScience(r controller.Repo, g game.Game, race, typeName string, d, w, s, c float64) error {
+	if err := g.CreateScience(race, typeName, d, w, s, c); err != nil {
+		return err
+	}
+	return r.SaveState(g)
+}
+
+func DeleteScience(configure func(*controller.Param), race, typeName string) (err error) {
+	control(configure, func(c *controller.Ctrl) {
+		c.Execute(func(r controller.Repo, g game.Game) {
+			err = deleteScience(r, g, race, typeName)
+		})
+	})
+	return
+}
+
+func deleteScience(r controller.Repo, g game.Game, race, typeName string) error {
+	if err := g.DeleteScience(race, typeName); err != nil {
+		return err
+	}
+	return r.SaveState(g)
+}
@@ -0,0 +1,90 @@
+package game_test
+
+import (
+	"strconv"
+	"testing"
+
+	"github.com/iliadenisov/galaxy/internal/controller"
+
+	e "github.com/iliadenisov/galaxy/internal/error"
+	"github.com/iliadenisov/galaxy/internal/game"
+	mg "github.com/iliadenisov/galaxy/internal/model/game"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestCreateScience(t *testing.T) {
+	race := "race_01"
+	typeName := "First Step"
+	g(t, func(p func(*controller.Param), g func() mg.Game) {
+		err := game.DeleteScience(p, race, typeName)
+		assert.ErrorContains(t, err, e.GenericErrorText(e.ErrInputEntityNotExists))
+		err = game.CreateScience(p, unknownRaceName, "  "+typeName+" ", 1, 0, 0, 0) // TODO: test on dead race
+		assert.ErrorContains(t, err, e.GenericErrorText(e.ErrInputUnknownRace))
+		err = game.CreateScience(p, race, "  "+typeName+" ", 1, 0, 0, 0)
+		assert.NoError(t, err)
+		sc, err := g().Sciences(race)
+		assert.NoError(t, err)
+		assert.Len(t, sc, 1)
+		assert.Equal(t, sc[0].Name, typeName)
+		assert.Equal(t, sc[0].Drive, 1.)
+		assert.Equal(t, sc[0].Weapons, 0.)
+		assert.Equal(t, sc[0].Shields, 0.)
+		assert.Equal(t, sc[0].Cargo, 0.)
+		// TODO: test delete with existing ship group
+		// TODO: test delete with planet production busy with science
+		err = game.DeleteScience(p, unknownRaceName, typeName) // TODO: test with actial rip race
+		assert.ErrorContains(t, err, e.GenericErrorText(e.ErrInputUnknownRace))
+		err = game.DeleteScience(p, race, typeName)
+		assert.NoError(t, err)
+		sc, err = g().Sciences(race)
+		assert.NoError(t, err)
+		assert.Len(t, sc, 0)
+	})
+}
+
+func TestCreateScienceValidation(t *testing.T) {
+	race := "race_01"
+	typeName := "First Step"
+	type tc struct {
+		name       string
+		d, w, s, c float64
+		err        string
+	}
+	table := []tc{
+		// correct values
+		{typeName, 1, 0, 0, 0, ""},
+		{typeName, 0.5, 0.5, 0, 0, ""},
+		{typeName, 0.25, 0.25, 0.25, 0.25, ""},
+		{typeName, 0.33, 0.33, 0.34, 0, ""},
+		{typeName, 0, 0, 0.99, 0.01, ""},
+		// incorrect values...
+		{"", 1, 0, 0, 0, e.GenericErrorText(e.ErrInputEntityTypeNameInvalid)},
+		{"  ", 1, 0, 0, 0, e.GenericErrorText(e.ErrInputEntityTypeNameInvalid)},
+		{typeName, 0, 0, 0, 0, e.GenericErrorText(e.ErrInputScienceSumValues)},
+		// drive
+		{typeName, -1, 0, 0, 0, e.GenericErrorText(e.ErrInputDriveValue)},
+		{typeName, -1, 2, 0, 0, e.GenericErrorText(e.ErrInputDriveValue)},
+		// weapons
+		{typeName, 0, -1, 0, 0, e.GenericErrorText(e.ErrInputWeaponsValue)},
+		{typeName, 2, -1, 0, 0, e.GenericErrorText(e.ErrInputWeaponsValue)},
+		// shields
+		{typeName, 0, 0, -1, 0, e.GenericErrorText(e.ErrInputShieldsValue)},
+		{typeName, 0.5, 0.5, -1, 0.5, e.GenericErrorText(e.ErrInputShieldsValue)},
+		// cargo
+		{typeName, 0, 0, 0, -1, e.GenericErrorText(e.ErrInputCargoValue)},
+		{typeName, 0, 1, 1, -1, e.GenericErrorText(e.ErrInputCargoValue)},
+	}
+	g(t, func(p func(*controller.Param), g func() mg.Game) {
+		for i, tc := range table {
+			if tc.err == "" {
+				err := game.CreateScience(p, race, tc.name+strconv.Itoa(i), tc.d, tc.w, tc.s, tc.c)
+				assert.NoError(t, err)
+				err = game.CreateScience(p, race, tc.name+strconv.Itoa(i), tc.d, tc.w, tc.s, tc.c)
+				assert.ErrorContains(t, err, e.GenericErrorText(e.ErrInputEntityTypeNameDuplicate))
+			} else {
+				err := game.CreateScience(p, race, tc.name, tc.d, tc.w, tc.s, tc.c)
+				assert.ErrorContains(t, err, tc.err)
+			}
+		}
+	})
+}
@@ -0,0 +1,54 @@
+package game
+
+import (
+	"github.com/iliadenisov/galaxy/internal/controller"
+	"github.com/iliadenisov/galaxy/internal/model/game"
+)
+
+func CreateShipType(configure func(*controller.Param), race, typeName string, drive, weapons, shields, cargo float64, armament int) (err error) {
+	control(configure, func(c *controller.Ctrl) {
+		c.Execute(func(r controller.Repo, g game.Game) {
+			err = createShipType(r, g, race, typeName, drive, weapons, shields, cargo, armament)
+		})
+	})
+	return
+}
+
+func createShipType(r controller.Repo, g game.Game, race, typeName string, d, w, s, c float64, a int) error {
+	if err := g.CreateShipType(race, typeName, d, w, s, c, a); err != nil {
+		return err
+	}
+	return r.SaveState(g)
+}
+
+func MergeShipType(configure func(*controller.Param), race, source, target string) (err error) {
+	control(configure, func(c *controller.Ctrl) {
+		c.Execute(func(r controller.Repo, g game.Game) {
+			err = mergeShipType(r, g, race, source, target)
+		})
+	})
+	return
+}
+
+func mergeShipType(r controller.Repo, g game.Game, race, source, target string) error {
+	if err := g.MergeShipType(race, source, target); err != nil {
+		return err
+	}
+	return r.SaveState(g)
+}
+
+func DeleteShipType(configure func(*controller.Param), race, typeName string) (err error) {
+	control(configure, func(c *controller.Ctrl) {
+		c.Execute(func(r controller.Repo, g game.Game) {
+			err = deleteShipType(r, g, race, typeName)
+		})
+	})
+	return
+}
+
+func deleteShipType(r controller.Repo, g game.Game, race, typeName string) error {
+	if err := g.DeleteShipType(race, typeName); err != nil {
+		return err
+	}
+	return r.SaveState(g)
+}
@@ -0,0 +1,119 @@
+package game_test
+
+import (
+	"strconv"
+	"testing"
+
+	"github.com/iliadenisov/galaxy/internal/controller"
+
+	e "github.com/iliadenisov/galaxy/internal/error"
+	"github.com/iliadenisov/galaxy/internal/game"
+	mg "github.com/iliadenisov/galaxy/internal/model/game"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestCreateShipType(t *testing.T) {
+	race := "race_01"
+	typeName := "Drone"
+	g(t, func(p func(*controller.Param), g func() mg.Game) {
+		err := game.DeleteShipType(p, race, typeName)
+		assert.ErrorContains(t, err, e.GenericErrorText(e.ErrInputEntityNotExists))
+		err = game.CreateShipType(p, unknownRaceName, "  "+typeName+" ", 1, 0, 0, 0, 0) // TODO: test on dead race
+		assert.ErrorContains(t, err, e.GenericErrorText(e.ErrInputUnknownRace))
+		err = game.CreateShipType(p, race, "  "+typeName+" ", 1, 0, 0, 0, 0)
+		assert.NoError(t, err)
+		st, err := g().ShipTypes(race)
+		assert.NoError(t, err)
+		assert.Len(t, st, 1)
+		assert.Equal(t, st[0].Name, typeName)
+		assert.Equal(t, st[0].Drive, 1.)
+		assert.Equal(t, st[0].Weapons, 0.)
+		assert.Equal(t, st[0].Shields, 0.)
+		assert.Equal(t, st[0].Cargo, 0.)
+		assert.Equal(t, st[0].Armament, uint(0))
+		// TODO: test with existing ship group
+		err = game.DeleteShipType(p, unknownRaceName, typeName) // TODO: test on dead race
+		assert.ErrorContains(t, err, e.GenericErrorText(e.ErrInputUnknownRace))
+		err = game.DeleteShipType(p, race, typeName)
+		assert.NoError(t, err)
+		st, err = g().ShipTypes(race)
+		assert.NoError(t, err)
+		assert.Len(t, st, 0)
+	})
+}
+
+func TestCreateShipTypeValidation(t *testing.T) {
+	race := "race_01"
+	typeName := "Drone"
+	type tc struct {
+		name       string
+		d, w, s, c float64
+		a          int
+		err        string
+	}
+	table := []tc{
+		// correct values
+		{typeName, 1, 0, 0, 0, 0, ""},
+		{typeName, 1.1, 0, 0, 0, 0, ""},
+		{typeName, 1, 1.2, 0, 0, 1, ""},
+		{typeName, 1, 1.2, 2.5, 0, 1, ""},
+		{typeName, 1, 0, 2.5, 7.7, 0, ""},
+		// incorrect values...
+		{"", 1, 0, 0, 0, 0, e.GenericErrorText(e.ErrInputEntityTypeNameInvalid)},
+		{"  ", 1, 0, 0, 0, 0, e.GenericErrorText(e.ErrInputEntityTypeNameInvalid)},
+		{typeName, 0, 0, 0, 0, 0, e.GenericErrorText(e.ErrInputShipTypeZeroValues)},
+		// drive
+		{typeName, -1, 0, 0, 0, 0, e.GenericErrorText(e.ErrInputDriveValue)},
+		{typeName, 0.5, 0, 0, 0, 0, e.GenericErrorText(e.ErrInputDriveValue)},
+		// weapons
+		{typeName, 0, -1, 0, 0, 0, e.GenericErrorText(e.ErrInputWeaponsValue)},
+		{typeName, 0, 0.5, 0, 0, 0, e.GenericErrorText(e.ErrInputWeaponsValue)},
+		// shields
+		{typeName, 0, 0, -1, 0, 0, e.GenericErrorText(e.ErrInputShieldsValue)},
+		{typeName, 0, 0, 0.5, 0, 0, e.GenericErrorText(e.ErrInputShieldsValue)},
+		// cargo
+		{typeName, 0, 0, 0, -1, 0, e.GenericErrorText(e.ErrInputCargoValue)},
+		{typeName, 0, 0, 0, 0.5, 0, e.GenericErrorText(e.ErrInputCargoValue)},
+		// armament (and weapons)
+		{typeName, 0, 0, 0, 0, -1, e.GenericErrorText(e.ErrInputShipTypeArmamentValue)},
+		{typeName, 0, 1, 0, 0, 0, e.GenericErrorText(e.ErrInputShipTypeWeaponsAndArmamentValue)},
+		{typeName, 0, 0, 0, 0, 1, e.GenericErrorText(e.ErrInputShipTypeWeaponsAndArmamentValue)},
+	}
+	g(t, func(p func(*controller.Param), g func() mg.Game) {
+		for i, tc := range table {
+			if tc.err == "" {
+				err := game.CreateShipType(p, race, tc.name+strconv.Itoa(i), tc.d, tc.w, tc.s, tc.c, tc.a)
+				assert.NoError(t, err)
+				err = game.CreateShipType(p, race, tc.name+strconv.Itoa(i), tc.d, tc.w, tc.s, tc.c, tc.a)
+				assert.ErrorContains(t, err, e.GenericErrorText(e.ErrInputEntityTypeNameDuplicate))
+			} else {
+				err := game.CreateShipType(p, race, tc.name, tc.d, tc.w, tc.s, tc.c, tc.a)
+				assert.ErrorContains(t, err, tc.err)
+			}
+		}
+	})
+}
+
+func TestMergeShipType(t *testing.T) {
+	race := "race_01"
+	g(t, func(p func(*controller.Param), g func() mg.Game) {
+		err := game.CreateShipType(p, race, "Drone", 1, 0, 0, 0, 0)
+		assert.NoError(t, err)
+		err = game.CreateShipType(p, race, "Spy", 1, 0, 0, 0, 0)
+		assert.NoError(t, err)
+		err = game.CreateShipType(p, race, "Cruiser", 15, 15, 15, 0, 1)
+		assert.NoError(t, err)
+		err = game.MergeShipType(p, race, "Sky", "Drone")
+		assert.ErrorContains(t, err, e.GenericErrorText(e.ErrInputEntityNotExists))
+		err = game.MergeShipType(p, race, "Spy", "Freighter")
+		assert.ErrorContains(t, err, e.GenericErrorText(e.ErrInputEntityNotExists))
+		err = game.MergeShipType(p, race, "Spy", "Drone")
+		assert.NoError(t, err)
+		st, err := g().ShipTypes(race)
+		assert.NoError(t, err)
+		assert.Len(t, st, 2)
+		err = game.MergeShipType(p, race, "Drone", "Cruiser")
+		assert.ErrorContains(t, err, e.GenericErrorText(e.ErrMergeShipTypeNotEqual))
+		// TODO: test group/production changed
+	})
+}
@@ -0,0 +1,27 @@
+package game
+
+import (
+	"github.com/iliadenisov/galaxy/internal/controller"
+	"github.com/iliadenisov/galaxy/internal/model/game"
+)
+
+func DeclareWar(configure func(*controller.Param), from, to string) (err error) {
+	control(configure, func(c *controller.Ctrl) {
+		c.Execute(func(r controller.Repo, g game.Game) { err = updateRelation(r, g, from, to, game.RelationWar) })
+	})
+	return
+}
+
+func DeclarePeace(configure func(*controller.Param), from, to string) (err error) {
+	control(configure, func(c *controller.Ctrl) {
+		c.Execute(func(r controller.Repo, g game.Game) { err = updateRelation(r, g, from, to, game.RelationPeace) })
+	})
+	return
+}
+
+func updateRelation(r controller.Repo, g game.Game, hostRace, opponentRace string, rel game.Relation) error {
+	if err := g.UpdateRelation(hostRace, opponentRace, rel); err != nil {
+		return err
+	}
+	return r.SaveState(g)
+}
@@ -0,0 +1,78 @@
+package game_test
+
+import (
+	"testing"
+
+	"github.com/iliadenisov/galaxy/internal/controller"
+	e "github.com/iliadenisov/galaxy/internal/error"
+
+	"github.com/iliadenisov/galaxy/internal/game"
+	mg "github.com/iliadenisov/galaxy/internal/model/game"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestDeclarePeaceAndWarSingle(t *testing.T) {
+	g(t, func(f func(*controller.Param), g func() mg.Game) {
+		hostRace := "race_05"
+		opponentRace := "race_01"
+
+		r, err := g().Relation(hostRace, opponentRace)
+		assert.NoError(t, err)
+		assert.Equal(t, mg.RelationWar, r.Relation)
+
+		r, err = g().Relation(unknownRaceName, opponentRace) // TODO: test on dead race
+		assert.ErrorContains(t, err, e.GenericErrorText(e.ErrInputUnknownRace))
+		r, err = g().Relation(hostRace, unknownRaceName) // TODO: test on dead race
+		assert.ErrorContains(t, err, e.GenericErrorText(e.ErrInputUnknownRace))
+
+		assert.NoError(t, game.DeclarePeace(f, hostRace, opponentRace))
+		r, err = g().Relation(hostRace, opponentRace)
+		assert.NoError(t, err)
+		assert.Equal(t, mg.RelationPeace, r.Relation)
+
+		assert.NoError(t, game.DeclareWar(f, hostRace, opponentRace))
+		r, err = g().Relation(hostRace, opponentRace)
+		assert.NoError(t, err)
+		assert.Equal(t, mg.RelationWar, r.Relation)
+	})
+}
+
+func TestDeclarePeaceAndWarAll(t *testing.T) {
+	g(t, func(f func(*controller.Param), g func() mg.Game) {
+		hostRace := "race_07"
+
+		for i := range testRaceCount {
+			opponentRace := raceNum(i)
+			if opponentRace == hostRace {
+				continue
+			}
+			r, err := g().Relation(hostRace, opponentRace)
+			assert.NoError(t, err)
+			assert.Equal(t, mg.RelationWar, r.Relation)
+		}
+
+		assert.NoError(t, game.DeclarePeace(f, hostRace, hostRace))
+
+		for i := range testRaceCount {
+			opponentRace := raceNum(i)
+			if opponentRace == hostRace {
+				continue
+			}
+			r, err := g().Relation(hostRace, opponentRace)
+			assert.NoError(t, err)
+			assert.Equal(t, mg.RelationPeace, r.Relation)
+		}
+
+		assert.NoError(t, game.DeclareWar(f, hostRace, hostRace))
+
+		for i := range testRaceCount {
+			opponentRace := raceNum(i)
+			if opponentRace == hostRace {
+				continue
+			}
+			r, err := g().Relation(hostRace, opponentRace)
+			assert.NoError(t, err)
+			assert.Equal(t, mg.RelationWar, r.Relation)
+		}
+	})
+}
@@ -0,0 +1,28 @@
+package game
+
+import (
+	"github.com/google/uuid"
+	"github.com/iliadenisov/galaxy/internal/controller"
+	"github.com/iliadenisov/galaxy/internal/model/game"
+)
+
+func LoadState(configure func(*controller.Param)) (g game.Game, err error) {
+	control(configure, func(c *controller.Ctrl) { c.ExecuteInit(func(r controller.Repo) { g, err = c.Repo.LoadState() }) })
+	return
+}
+
+func GenerateGame(configure func(*controller.Param), races []string) (gameID uuid.UUID, err error) {
+	control(configure, func(c *controller.Ctrl) {
+		c.ExecuteInit(func(r controller.Repo) { gameID, err = controller.NewGame(r, races) })
+	})
+	return
+}
+
+func control(configure func(*controller.Param), consumer func(*controller.Ctrl)) error {
+	c, err := controller.NewController(configure)
+	if err != nil {
+		return err
+	}
+	consumer(c)
+	return nil
+}
@@ -0,0 +1,54 @@
+package game_test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/iliadenisov/galaxy/internal/controller"
+
+	"github.com/iliadenisov/galaxy/internal/game"
+	mg "github.com/iliadenisov/galaxy/internal/model/game"
+	"github.com/iliadenisov/galaxy/internal/util"
+	"github.com/stretchr/testify/assert"
+)
+
+const (
+	testRaceCount   = 20
+	unknownRaceName = "Race_RIP"
+)
+
+func raceNum(i int) string {
+	return fmt.Sprintf("race_%02d", i)
+}
+
+func TestComposeGame(t *testing.T) {
+	g(t, func(p func(*controller.Param), g func() mg.Game) {
+		_, err := game.GenerateGame(p, []string{"r1", "r2"})
+		assert.Error(t, err)
+		assert.ErrorContains(t, err, "state for turn 0 already saved")
+	})
+}
+
+func g(t *testing.T, f func(p func(*controller.Param), g func() mg.Game)) {
+	root, cleanup := util.CreateWorkDir(t)
+	defer cleanup()
+	races := make([]string, testRaceCount)
+	for i := range testRaceCount {
+		races[i] = raceNum(i)
+	}
+	p := func(p *controller.Param) { p.StoragePath = root }
+	_, err := game.GenerateGame(p, races)
+	if err != nil {
+		assert.FailNow(t, "g: ComposeGame", err)
+		return
+	}
+	g := func() mg.Game {
+		g, err := game.LoadState(p)
+		if err != nil {
+			assert.FailNow(t, "g: LoadState", err)
+			return mg.Game{}
+		}
+		return g
+	}
+	f(p, g)
+}