Testing a Function by Passing Input Multiple Times

Question

I'm learning Go with tests. I ended up with the below program from the end of chapter 2 in "Head First Go".

It gives the user three attempts to guess a number from 1 to 10:

guess.go

package main

import (
    "fmt"
    "math/rand"
    "time"
    "bufio"
    "os"
    "log"
    "strconv"
    "strings"
)

func generateRandomNumber() int {
    rand.Seed(time.Now().Unix())       // seed value based on time to generate non-deterministic random values
    randomNum := rand.Intn(10) + 1     // range: [0, 10); produces the same value without Seed(), i.e., pseudo-random
    return randomNum
}

func guess() int {
    var success bool = false
    target := generateRandomNumber()

    fmt.Println("Guess a number between 1 and 10")
    guess  := bufio.NewReader(os.Stdin)

    for attempts := 0; attempts < 3; attempts++ {
        fmt.Println("You have", 3-attempts, "guesses left")
        userVal, err := guess.ReadString('\n')
        if err != nil {
            log.Fatal(err)
        }
    
        input := strings.TrimSpace(userVal)
        answer, err := strconv.Atoi(input)
        if err != nil {
            log.Fatal(err)
        }
    
        if answer == target {
            fmt.Println("Congratulations !!")
            return answer
        } else if answer > target {
            fmt.Println("Your guess was HIGHER")
        } else if answer < target {
            fmt.Println("Your guess was LOWER")
        }
    }

    if !success {
        fmt.Printf("Sorry, you've run out of attempts... The correct value is %d\n", target)
        return target   
    }
    return 0
}

func main() {
    guess()
}

guess_test.go

package main

import (
    "testing"
)

func TestRandomNumber(t *testing.T) {
    want := generateRandomNumber()
    
    if 7 != want {
        t.Fail()
        t.Logf("Incorrect guess; The random number was %d", want)
    }
}

How can I test guess() by passing in three different inputs?

I would like to perform a test by comparing the return value of guess() with generateRandomNumber().

Answer 1

You can change guess function to get reader from input, by this we able to pass it any reader we want: in main we pass stdin reader and in test we pass mock reader:

guess.go

package main

import (
    "bufio"
    "fmt"
    "log"
    "math/rand"
    "os"
    "strconv"
    "strings"
    "time"
)

func generateRandomNumber() int {
    rand.Seed(time.Now().Unix())   // seed value based on time to generate non-deterministic random values
    randomNum := rand.Intn(10) + 1 // range: [0, 10); produces the same value without Seed(), i.e., pseudo-random
    return randomNum
}

func guess(reader *bufio.Reader) (int, error) {
    target := generateRandomNumber()

    fmt.Println("Guess a number between 1 and 10")

    for attempts := 0; attempts < 3; attempts++ {
        fmt.Println("You have", 3-attempts, "guesses left")
        userVal, err := reader.ReadString('\n')
        if err != nil {
            log.Fatal(err)
        }

        input := strings.TrimSpace(userVal)
        answer, err := strconv.Atoi(input)
        if err != nil {
            log.Fatal(err)
        }

        if answer == target {
            fmt.Println("Congratulations !!")
            return answer, nil
        } else if answer > target {
            fmt.Println("Your guess was HIGHER")
        } else if answer < target {
            fmt.Println("Your guess was LOWER")
        }
    }

    fmt.Printf("Sorry, you've run out of attempts... The correct value is %d\n", target)
    return target, fmt.Errorf("attempts is over")
}

func main() {
    reader := bufio.NewReader(os.Stdin)
    guess(reader)
}

for testing:

guess_test.go

package main

import (
    "bufio"
    "fmt"
    "strings"
    "testing"
)

func TestRandomNumberOk(t *testing.T) {
    want := generateRandomNumber()
    msg := fmt.Sprintf("3\n4\n%d\n", want)
    reader := strings.NewReader(msg)
    r := bufio.NewReader(reader)
    _, err := guess(r)
    if err != nil {
        t.Errorf("guess must successfull")
    }
}

func TestRandomNumberFail(t *testing.T) {
    want := generateRandomNumber()
    msg := fmt.Sprintf("3\n4\n%d\n", want+1)
    reader := strings.NewReader(msg)
    r := bufio.NewReader(reader)
    _, err := guess(r)
    if err == nil {
        t.Errorf("guess must unsuccessfull")
    }
}

I had to change your guess return value, because it's unknown when it's successful or not