Merge pull request #12 from chrisreddington/increase-test-coverage

Increase test coverage

Author: chrisreddington

cmd/cointoss.go

@@ -2,10 +2,10 @@ package cmd
 
 import (
 	"fmt"
-	"strings"
-
-	"github.com/chrisreddington/gh-game/internal/cointoss" // adjust import path as needed
+	"os"
 
+	"github.com/chrisreddington/gh-game/internal/cointoss"
+	userPrompt "github.com/cli/go-gh/v2/pkg/prompter"
 	"github.com/spf13/cobra"
 )
 
@@ -20,24 +20,11 @@ var cointossCmd = &cobra.Command{
 		return cointoss.ValidateGuess(args[0])
 	},
 	Run: func(cmd *cobra.Command, args []string) {
-		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))
-
-			if guess == result {
-				streak++
-				fmt.Printf("Correct! Streak: %d\n", streak)
-				var continuePlay bool
-				guess, continuePlay = cointoss.GetNextGuess()
-				keepPlaying = continuePlay
-			} else {
-				fmt.Printf("Game Over! Final streak: %d\n", streak)
-				keepPlaying = false
-			}
-		}
+		input := userPrompt.New(os.Stdin, os.Stdout, os.Stderr)
+		cointoss.PlayGame(input, args[0])
 	},
 }
+
+func init() {
+	rootCmd.AddCommand(cointossCmd)
+}

internal/cointoss/cointoss.go

@@ -3,19 +3,30 @@ 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 TossCoin() string {
+func NewGame() *Game {
+	return &Game{
+		IsOver: false,
+	}
+}
+
+// TossCoin is a variable so it can be replaced in tests
+var TossCoin = func() string {
 	rand.Seed(time.Now().UnixNano())
 	if rand.Float32() < 0.5 {
 		return "heads"
@@ -31,11 +42,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 +59,40 @@ 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)
+}
+
+// PlayGame handles the main game loop
+func PlayGame(p prompter, initialGuess string) {
+	game := NewGame()
+	streak := 0
+	keepPlaying := true
+	guess := strings.ToLower(strings.TrimSpace(initialGuess))
+
+	for keepPlaying {
+		game.Play(guess)
+		fmt.Println(game.GetResult())
+		
+		if game.PlayerGuess == game.Result {
+			streak++
+			fmt.Printf("Streak: %d\n", streak)
+			guess, keepPlaying = GetPlayerGuess(p)
+		} else {
+			fmt.Printf("Game Over! Final streak: %d\n", streak)
+			keepPlaying = false
+		}
+	}
+}

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,143 @@ 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)
+}
+
+func TestPlayGame(t *testing.T) {
+	tests := []struct {
+		name         string
+		selectAnswer int
+		selectError  error
+		initialGuess string
+		results      []string // sequence of coin flip results to test
+	}{
+		{
+			name:         "win first round then quit",
+			selectAnswer: 2, // quit
+			initialGuess: "heads",
+			results:      []string{"heads"},
+		},
+		{
+			name:         "lose first round",
+			initialGuess: "heads",
+			results:      []string{"tails"},
+		},
+		{
+			name:         "win twice then lose",
+			selectAnswer: 0, // heads
+			initialGuess: "heads",
+			results:      []string{"heads", "heads", "tails"},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			mockP := &mockPrompter{
+				selectAnswer: tt.selectAnswer,
+				selectError:  tt.selectError,
+			}
+
+			// Override TossCoin for deterministic testing
+			resultIndex := 0
+			oldTossCoin := TossCoin
+			TossCoin = func() string {
+				result := tt.results[resultIndex]
+				if resultIndex < len(tt.results)-1 {
+					resultIndex++
+				}
+				return result
+			}
+			defer func() { TossCoin = oldTossCoin }()
+
+			PlayGame(mockP, tt.initialGuess)
 		})
 	}
 }