Refactor Sudoku field and solver implementation

sudoku/sudoku.go

@@ -14,36 +14,43 @@ type Game struct {
 	solver logic.Solver
 }
 
-func New(parser parser.Parser, solver logic.Solver, data []byte) (*Game, error) {
-	err := parser.Parse(data)
-	if err != nil {
-		return &Game{}, fmt.Errorf("can not create game: %w", err)
+func New(input parser.Parser, solver logic.Solver, data []byte, fieldIndex int) (*Game, error) {
+	if input == nil {
+		return nil, errors.New("cannot create game: nil parser")
 	}
-	return &Game{solver: solver, field: parser.GetField(2)}, nil
+	if err := input.Parse(data); err != nil {
+		return nil, fmt.Errorf("cannot create game: %w", err)
+	}
+	parsedField, err := input.GetField(fieldIndex)
+	if err != nil {
+		return nil, fmt.Errorf("cannot create game: %w", err)
+	}
+	if parsedField == nil || !parsedField.IsValid() {
+		return nil, fmt.Errorf("cannot create game: %w", field.ErrInvalidField)
+	}
+	return &Game{solver: solver, field: parsedField}, nil
 }
 
 func (g *Game) Solve() error {
-	g.solver.InitStragies(g.field)
-	for !g.isFinished() {
-		if !g.nextSolveStep() {
-			return errors.New("no strategy can solve the puzzle")
-		}
+	if g == nil || g.field == nil {
+		return field.ErrInvalidField
+	}
+	if err := g.solver.InitStrategies(g.field); err != nil {
+		return err
+	}
+	solved, err := g.solver.Run(0)
+	if err != nil {
+		return err
+	}
+	if !solved {
+		return logic.ErrNoProgress
 	}
 	return nil
 }
 
-func (g *Game) nextSolveStep() bool {
-	return g.solver.Run(0)
-}
-
-func (g *Game) prevSolveStep() {
-	// far far in the future
-}
-
-func (g *Game) isFinished() bool {
-	return g.field.IsSolved()
-}
-
-func (g *Game) GetField() field.Field {
-	return *g.field
+func (g *Game) GetField() *field.Field {
+	if g == nil {
+		return nil
+	}
+	return g.field
 }

sudoku/sudoku_test.go

@@ -0,0 +1,65 @@
+package sudoku
+
+import (
+	"crypto/sha1"
+	"errors"
+	"fmt"
+	"testing"
+
+	"git.kleiax.de/homepage/logic"
+	"git.kleiax.de/homepage/logic/strategies"
+	"git.kleiax.de/homepage/parser"
+)
+
+const solvedSudoku = "123456789456789123789123456234567891567891234891234567345678912678912345912345678"
+
+func puzzleBankRecord(digits string, rating float64) string {
+	hash := fmt.Sprintf("%x", sha1.Sum([]byte(digits)))[:12]
+	return fmt.Sprintf("%s %s   %.1f", hash, digits, rating)
+}
+
+func TestNewSelectsExplicitPuzzleIndex(t *testing.T) {
+	data := puzzleBankRecord("0"+solvedSudoku[1:], 1.0) + "\n" + puzzleBankRecord(solvedSudoku, 2.0)
+	game, err := New(&parser.PuzzleBank{}, logic.Solver{}, []byte(data), 1)
+	if err != nil {
+		t.Fatalf("New() error = %v", err)
+	}
+	if game.GetField().GetRating() != 2 || !game.GetField().IsSolved() {
+		t.Fatal("New() did not select puzzle index 1")
+	}
+}
+
+func TestNewRejectsInvalidIndexAndInput(t *testing.T) {
+	valid := puzzleBankRecord(solvedSudoku, 1.0)
+	if _, err := New(&parser.PuzzleBank{}, logic.Solver{}, []byte(valid), 1); !errors.Is(err, parser.ErrFieldIndex) {
+		t.Fatalf("index error = %v, want ErrFieldIndex", err)
+	}
+	if _, err := New(&parser.PuzzleString{}, logic.Solver{}, []byte("invalid"), 0); err == nil {
+		t.Fatal("invalid input error = nil")
+	}
+}
+
+func TestSolveCompletesSimplePuzzle(t *testing.T) {
+	solver := logic.Solver{}
+	solver.Add(&strategies.LastDigit{})
+	game, err := New(&parser.PuzzleString{}, solver, []byte("0"+solvedSudoku[1:]), 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := game.Solve(); err != nil {
+		t.Fatalf("Solve() error = %v", err)
+	}
+	if !game.GetField().IsSolved() {
+		t.Fatal("field is not solved")
+	}
+}
+
+func TestSolveReportsNoProgress(t *testing.T) {
+	game, err := New(&parser.PuzzleString{}, logic.Solver{}, []byte("0"+solvedSudoku[1:]), 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := game.Solve(); !errors.Is(err, logic.ErrNoProgress) {
+		t.Fatalf("Solve() error = %v, want ErrNoProgress", err)
+	}
+}