Refactor coin toss game logic and enhance player interaction with structured game state management

Author: chrisreddington

cmd/cointoss.go

@@ -2,10 +2,11 @@ package cmd
 
 import (
 	"fmt"
+	"os"
 	"strings"
 
-	"github.com/chrisreddington/gh-game/internal/cointoss" // adjust import path as needed
-
+	"github.com/chrisreddington/gh-game/internal/cointoss"
+	userPrompt "github.com/cli/go-gh/v2/pkg/prompter"
 	"github.com/spf13/cobra"
 )
 
@@ -20,20 +21,20 @@ var cointossCmd = &cobra.Command{
 		return cointoss.ValidateGuess(args[0])
 	},
 	Run: func(cmd *cobra.Command, args []string) {
+		game := cointoss.NewGame()
+		prompter := userPrompt.New(os.Stdin, os.Stdout, os.Stderr)
 		guess := strings.ToLower(strings.TrimSpace(args[0]))
 		streak := 0
 		keepPlaying := true
 
 		for keepPlaying {
-			result := cointoss.TossCoin()
-			fmt.Printf("The coin shows: %s!\n", strings.Title(result))
+			game.Play(guess)
+			fmt.Println(game.GetResult())
 
-			if guess == result {
+			if game.PlayerGuess == game.Result {
 				streak++
-				fmt.Printf("Correct! Streak: %d\n", streak)
-				var continuePlay bool
-				guess, continuePlay = cointoss.GetNextGuess()
-				keepPlaying = continuePlay
+				fmt.Printf("Streak: %d\n", streak)
+				guess, keepPlaying = cointoss.GetPlayerGuess(prompter)
 			} else {
 				fmt.Printf("Game Over! Final streak: %d\n", streak)
 				keepPlaying = false

internal/cointoss/cointoss.go

@@ -3,18 +3,28 @@ package cointoss
 import (
 	"fmt"
 	"math/rand"
-	"os"
 	"strings"
 	"time"
-
-	userPrompt "github.com/cli/go-gh/v2/pkg/prompter"
 )
 
+// Game represents the state of a coin toss game
+type Game struct {
+	PlayerGuess string
+	Result      string
+	IsOver      bool
+}
+
 // prompter interface allows us to mock the prompt functionality in tests
 type prompter interface {
 	Select(prompt string, defaultValue string, options []string) (int, error)
 }
 
+func NewGame() *Game {
+	return &Game{
+		IsOver: false,
+	}
+}
+
 func TossCoin() string {
 	rand.Seed(time.Now().UnixNano())
 	if rand.Float32() < 0.5 {
@@ -31,11 +41,8 @@ func ValidateGuess(guess string) error {
 	return nil
 }
 
-func GetNextGuess() (string, bool) {
-	return GetNextGuessWithPrompter(userPrompt.New(os.Stdin, os.Stdout, os.Stderr))
-}
-
-func GetNextGuessWithPrompter(p prompter) (string, bool) {
+// GetPlayerGuess gets the player's next guess using the provided prompter
+func GetPlayerGuess(p prompter) (string, bool) {
 	options := []string{"Heads", "Tails", "Quit"}
 
 	answer, err := p.Select("What's your next guess? Heads, Tails or Quit?", "Heads", options)
@@ -51,3 +58,18 @@ func GetNextGuessWithPrompter(p prompter) (string, bool) {
 
 	return answerLower, true
 }
+
+// Play executes a round of the coin toss game
+func (g *Game) Play(guess string) {
+	g.PlayerGuess = guess
+	g.Result = TossCoin()
+	g.IsOver = true
+}
+
+// GetResult returns the game result message
+func (g *Game) GetResult() string {
+	if g.PlayerGuess == g.Result {
+		return fmt.Sprintf("You guessed %s and the coin landed on %s. You win!", g.PlayerGuess, g.Result)
+	}
+	return fmt.Sprintf("You guessed %s but the coin landed on %s. You lose!", g.PlayerGuess, g.Result)
+}

internal/cointoss/cointoss_test.go

@@ -2,6 +2,7 @@ package cointoss
 
 import (
 	"errors"
+	"strings"
 	"testing"
 )
 
@@ -41,7 +42,7 @@ func TestTossCoin(t *testing.T) {
 	}
 }
 
-func TestGetNextGuessWithPrompter(t *testing.T) {
+func TestGetPlayerGuess(t *testing.T) {
 	tests := []struct {
 		name          string
 		selectAnswer  int
@@ -77,13 +78,6 @@ func TestGetNextGuessWithPrompter(t *testing.T) {
 			expectedGuess: "",
 			expectedCont:  false,
 		},
-		{
-			name:          "error during selection prints error message",
-			selectAnswer:  0,
-			selectError:   errors.New("test error"),
-			expectedGuess: "",
-			expectedCont:  false,
-		},
 	}
 
 	for _, tt := range tests {
@@ -92,15 +86,92 @@ func TestGetNextGuessWithPrompter(t *testing.T) {
 				selectAnswer: tt.selectAnswer,
 				selectError:  tt.selectError,
 			}
-
-			guess, cont := GetNextGuessWithPrompter(mockP)
-
+			guess, cont := GetPlayerGuess(mockP)
 			if guess != tt.expectedGuess {
-				t.Errorf("GetNextGuessWithPrompter() guess = %v, want %v", guess, tt.expectedGuess)
+				t.Errorf("GetPlayerGuess() guess = %v, want %v", guess, tt.expectedGuess)
 			}
 			if cont != tt.expectedCont {
-				t.Errorf("GetNextGuessWithPrompter() cont = %v, want %v", cont, tt.expectedCont)
+				t.Errorf("GetPlayerGuess() cont = %v, want %v", cont, tt.expectedCont)
 			}
 		})
 	}
 }
+
+func TestGame_Play(t *testing.T) {
+	game := NewGame()
+
+	// Test initial state
+	if game.IsOver {
+		t.Error("New game should not be over")
+	}
+
+	// Play a round
+	game.Play("heads")
+
+	// Test that game state is updated
+	if !game.IsOver {
+		t.Error("Game should be over after playing")
+	}
+	if game.PlayerGuess != "heads" {
+		t.Errorf("PlayerGuess = %v, want heads", game.PlayerGuess)
+	}
+	if game.Result != "heads" && game.Result != "tails" {
+		t.Errorf("Result = %v, want either heads or tails", game.Result)
+	}
+}
+
+func TestGame_GetResult(t *testing.T) {
+	tests := []struct {
+		name        string
+		playerGuess string
+		result      string
+		wantWin     bool
+	}{
+		{
+			name:        "player wins with heads",
+			playerGuess: "heads",
+			result:      "heads",
+			wantWin:     true,
+		},
+		{
+			name:        "player wins with tails",
+			playerGuess: "tails",
+			result:      "tails",
+			wantWin:     true,
+		},
+		{
+			name:        "player loses with heads",
+			playerGuess: "heads",
+			result:      "tails",
+			wantWin:     false,
+		},
+		{
+			name:        "player loses with tails",
+			playerGuess: "tails",
+			result:      "heads",
+			wantWin:     false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			game := &Game{
+				PlayerGuess: tt.playerGuess,
+				Result:      tt.result,
+				IsOver:      true,
+			}
+			got := game.GetResult()
+			if tt.wantWin && !contains(got, "You win!") {
+				t.Errorf("GetResult() = %v, want win message", got)
+			}
+			if !tt.wantWin && !contains(got, "You lose!") {
+				t.Errorf("GetResult() = %v, want lose message", got)
+			}
+		})
+	}
+}
+
+// Helper function to check if a string contains a substring
+func contains(s, substr string) bool {
+	return strings.Contains(s, substr)
+}