Aprenda Go com Testes
Search…
1.0.0
Primeiros Passos com Go
Criando uma aplicação
Perguntas e respostas
Tempo
The product owner wants us to expand the functionality of our command line application by helping a group of people play Texas-Holdem Poker.
Just enough information on poker
You wont need to know much about poker, only that at certain time intervals all the players need to be informed of a steadily increasing "blind" value.
Our application will help keep track of when the blind should go up, and how much it should be.
- When it starts it asks how many players are playing. This determines the amount of time there is before the "blind" bet goes up.
- There is a base amount of time of 5 minutes.
- For every player, 1 minute is added.
- e.g 6 players equals 11 minutes for the blind.
- After the blind time expires the game should alert the players the new amount the blind bet is.
- The blind starts at 100 chips, then 200, 400, 600, 1000, 2000 and continue to double until the game ends (our previous functionality of "Ruth wins" should still finish the game)
Reminder of the code
In the previous chapter we made our start to the command line application which already accepts a command of
{name} wins. Here is what the current CLI code looks like, but be sure to familiarise yourself with the other code too before starting.1
type CLI struct {
2
playerStore PlayerStore
3
in *bufio.Scanner
4
}
5
6
func NewCLI(store PlayerStore, in io.Reader) *CLI {
7
return &CLI{
8
playerStore: store,
9
in: bufio.NewScanner(in),
10
}
11
}
12
13
func (cli *CLI) PlayPoker() {
14
userInput := cli.readLine()
15
cli.playerStore.RecordWin(extractWinner(userInput))
16
}
17
18
func extractWinner(userInput string) string {
19
return strings.Replace(userInput, " wins", "", 1)
20
}
21
22
func (cli *CLI) readLine() string {
23
cli.in.Scan()
24
return cli.in.Text()
25
}
Copied!
time.AfterFunc
time.AfterFuncWe want to be able to schedule our program to print the blind bet values at certain durations dependant on the number of players.
To limit the scope of what we need to do, we'll forget about the number of players part for now and just assume there are 5 players so we'll test that every 10 minutes the new value of the blind bet is printed.
AfterFuncwaits for the duration to elapse and then calls f in its own goroutine. It returns aTimerthat can be used to cancel the call using its Stop method.
A Duration represents the elapsed time between two instants as an int64 nanosecond count.
The time library has a number of constants to let you multiply those nanoseconds so they're a bit more readable for the kind of scenarios we'll be doing
1
5 * time.Second
Copied!
When we call
PlayPoker we'll schedule all of our blind alerts.Testing this may be a little tricky though. We'll want to verify that each time period is scheduled with the correct blind amount but if you look at the signature of
time.AfterFunc its second argument is the function it will run. You cannot compare functions in Go so we'd be unable to test what function has been sent in. So we'll need to write some kind of wrapper around time.AfterFunc which will take the time to run and the amount to print so we can spy on that.Write the test first
Add a new test to our suite
1
t.Run("it schedules printing of blind values", func(t *testing.T) {
2
in := strings.NewReader("Chris wins\n")
3
playerStore := &poker.StubPlayerStore{}
4
blindAlerter := &SpyBlindAlerter{}
5
6
cli := poker.NewCLI(playerStore, in, blindAlerter)
7
cli.PlayPoker()
8
9
if len(blindAlerter.alerts) != 1 {
10
t.Fatal("expected a blind alert to be scheduled")
11
}
12
})
Copied!
You'll notice we've made a
SpyBlindAlerter which we are trying to inject into our CLI and then checking that after we call PlayerPoker that an alert is scheduled.(Remember we are just going for the simplest scenario first and then we'll iterate.)
Here's the definition of
SpyBlindAlerter1
type SpyBlindAlerter struct {
2
alerts []struct{
3
scheduledAt time.Duration
4
amount int
5
}
6
}
7
8
func (s *SpyBlindAlerter) ScheduleAlertAt(duration time.Duration, amount int) {
9
s.alerts = append(s.alerts, struct {
10
scheduledAt time.Duration
11
amount int
12
}{duration, amount})
13
}
Copied!
Try to run the test
1
./CLI_test.go:32:27: too many arguments in call to poker.NewCLI
2
have (*poker.StubPlayerStore, *strings.Reader, *SpyBlindAlerter)
3
want (poker.PlayerStore, io.Reader)
Copied!
Write the minimal amount of code for the test to run and check the failing test output
We have added a new argument and the compiler is complaining. Strictly speaking the minimal amount of code is to make
NewCLI accept a *SpyBlindAlerter but let's cheat a little and just define the dependency as an interface.1
type BlindAlerter interface {
2
ScheduleAlertAt(duration time.Duration, amount int)
3
}
Copied!
And then add it to the constructor
1
func NewCLI(store PlayerStore, in io.Reader, alerter BlindAlerter) *CLI
Copied!
Your other tests will now fail as they dont have a
BlindAlerter passed in to NewCLI.Spying on BlindAlerter is not relevant for the other tests so in the test file add
1
var dummySpyAlerter = &SpyBlindAlerter{}
Copied!
Then use that in the other tests to fix the compilation problems. By labelling it as a "dummy" it is clear to the reader of the test that it is not important.
The tests should now compile and our new test fails.
1
=== RUN TestCLI
2
=== RUN TestCLI/it_schedules_printing_of_blind_values
3
--- FAIL: TestCLI (0.00s)
4
--- FAIL: TestCLI/it_schedules_printing_of_blind_values (0.00s)
5
CLI_test.go:38: expected a blind alert to be scheduled
Copied!
Write enough code to make it pass
We'll need to add the
BlindAlerter as a field on our CLI so we can reference it in our PlayPoker method.1
type CLI struct {
2
playerStore PlayerStore
3
in *bufio.Reader
4
alerter BlindAlerter
5
}
6
7
func NewCLI(store PlayerStore, in io.Reader, alerter BlindAlerter) *CLI {
8
return &CLI{
9
playerStore: store,
10
in: bufio.NewReader(in),
11
alerter: alerter,
12
}
13
}
Copied!
To make the test pass, we can call our
BlindAlerter with anything we like1
func (cli *CLI) PlayPoker() {
2
cli.alerter.ScheduleAlertAt(5 * time.Second, 100)
3
userInput := cli.readLine()
4
cli.playerStore.RecordWin(extractWinner(userInput))
5
}
Copied!
Next we'll want to check it schedules all the alerts we'd hope for, for 5 players
Write the test first
1
t.Run("it schedules printing of blind values", func(t *testing.T) {
2
in := strings.NewReader("Chris wins\n")
3
playerStore := &poker.StubPlayerStore{}
4
blindAlerter := &SpyBlindAlerter{}
5
6
cli := poker.NewCLI(playerStore, in, blindAlerter)
7
cli.PlayPoker()
8
9
cases := []struct{
10
expectedScheduleTime time.Duration
11
expectedAmount int
12
} {
13
{0 * time.Second, 100},
14
{10 * time.Minute, 200},
15
{20 * time.Minute, 300},
16
{30 * time.Minute, 400},
17
{40 * time.Minute, 500},
18
{50 * time.Minute, 600},
19
{60 * time.Minute, 800},
20
{70 * time.Minute, 1000},
21
{80 * time.Minute, 2000},
22
{90 * time.Minute, 4000},
23
{100 * time.Minute, 8000},
24
}
25
26
for i, c := range cases {
27
t.Run(fmt.Sprintf("%d scheduled for %v", c.expectedAmount, c.expectedScheduleTime), func(t *testing.T) {
28
29
if len(blindAlerter.alerts) <= i {
30
t.Fatalf("alert %d was not scheduled %v", i, blindAlerter.alerts)
31
}
32
33
alert := blindAlerter.alerts[i]
34
35
amountGot := alert.amount
36
if amountGot != c.expectedAmount {
37
t.Errorf("got amount %d, want %d", amountGot, c.expectedAmount)
38
}
39
40
gotScheduledTime := alert.scheduledAt
41
if gotScheduledTime != c.expectedScheduleTime {
42
t.Errorf("got scheduled time of %v, want %v", gotScheduledTime, c.expectedScheduleTime)
43
}
44
})
45
}
46
})
Copied!
Table-based test works nicely here and clearly illustrate what our requirements are. We run through the table and check the
SpyBlindAlerter to see if the alert has been scheduled with the correct values.Try to run the test
You should have a lot of failures looking like this
1
=== RUN TestCLI
2
--- FAIL: TestCLI (0.00s)
3
=== RUN TestCLI/it_schedules_printing_of_blind_values
4
--- FAIL: TestCLI/it_schedules_printing_of_blind_values (0.00s)
5
=== RUN TestCLI/it_schedules_printing_of_blind_values/100_scheduled_for_0s
6
--- FAIL: TestCLI/it_schedules_printing_of_blind_values/100_scheduled_for_0s (0.00s)
7
CLI_test.go:71: got scheduled time of 5s, want 0s
8
=== RUN TestCLI/it_schedules_printing_of_blind_values/200_scheduled_for_10m0s
9
--- FAIL: TestCLI/it_schedules_printing_of_blind_values/200_scheduled_for_10m0s (0.00s)
10
CLI_test.go:59: alert 1 was not scheduled [{5000000000 100}]
Copied!
Write enough code to make it pass
1
func (cli *CLI) PlayPoker() {
2
3
blinds := []int{100, 200, 300, 400, 500, 600, 800, 1000, 2000, 4000, 8000}
4
blindTime := 0 * time.Second
5
for _, blind := range blinds {
6
cli.alerter.ScheduleAlertAt(blindTime, blind)
7
blindTime = blindTime + 10 * time.Minute
8
}
9
10
userInput := cli.readLine()
11
cli.playerStore.RecordWin(extractWinner(userInput))
12
}
Copied!
It's not a lot more complicated than what we already had. We're just now iterating over an array of
blinds and calling the scheduler on an increasing blindTimeRefactor
We can encapsulate our scheduled alerts into a method just to make
PlayPoker read a little clearer.1
func (cli *CLI) PlayPoker() {
2
cli.scheduleBlindAlerts()
3
userInput := cli.readLine()
4
cli.playerStore.RecordWin(extractWinner(userInput))
5
}
6
7
func (cli *CLI) scheduleBlindAlerts() {
8
blinds := []int{100, 200, 300, 400, 500, 600, 800, 1000, 2000, 4000, 8000}
9
blindTime := 0 * time.Second
10
for _, blind := range blinds {
11
cli.alerter.ScheduleAlertAt(blindTime, blind)
12
blindTime = blindTime + 10*time.Minute
13
}
14
}
Copied!
Finally our tests are looking a little clunky. We have two anonymous structs representing the same thing, a
ScheduledAlert. Let's refactor that into a new type and then make some helpers to compare them.1
type scheduledAlert struct {
2
at time.Duration
3
amount int
4
}
5
6
func (s scheduledAlert) String() string {
7
return fmt.Sprintf("%d chips at %v", s.amount, s.at)
8
}
9
10
type SpyBlindAlerter struct {
11
alerts []scheduledAlert
12
}
13
14
func (s *SpyBlindAlerter) ScheduleAlertAt(at time.Duration, amount int) {
15
s.alerts = append(s.alerts, scheduledAlert{at, amount})
16
}
Copied!
We've added a
String() method to our type so it prints nicely if the test failsUpdate our test to use our new type
1
t.Run("it schedules printing of blind values", func(t *testing.T) {
2
in := strings.NewReader("Chris wins\n")
3
playerStore := &poker.StubPlayerStore{}
4
blindAlerter := &SpyBlindAlerter{}
5
6
cli := poker.NewCLI(playerStore, in, blindAlerter)
7
cli.PlayPoker()
8
9
cases := []scheduledAlert {
10
{0 * time.Second, 100},
11
{10 * time.Minute, 200},
12
{20 * time.Minute, 300},
13
{30 * time.Minute, 400},
14
{40 * time.Minute, 500},
15
{50 * time.Minute, 600},
16
{60 * time.Minute, 800},
17
{70 * time.Minute, 1000},
18
{80 * time.Minute, 2000},
19
{90 * time.Minute, 4000},
20
{100 * time.Minute, 8000},
21
}
22
23
for i, want := range cases {
24
t.Run(fmt.Sprint(want), func(t *testing.T) {
25
26
if len(blindAlerter.alerts) <= i {
27
t.Fatalf("alert %d was not scheduled %v", i, blindAlerter.alerts)
28
}
29
30
got := blindAlerter.alerts[i]
31
assertScheduledAlert(t, got, want)
32
})
33
}
34
})
Copied!
Implement
assertScheduledAlert yourself.We've spent a fair amount of time here writing tests and have been somewhat naughty not integrating with our application. Let's address that before we pile on any more requirements.
Try running the app and it wont compile, complaining about not enough args to
NewCLI.Let's create an implementation of
BlindAlerter that we can use in our application.Create
BlindAlerter.go and move our BlindAlerter interface and add the new things below1
package poker
2
3
import (
4
"time"
5
"fmt"
6
"os"
7
)
8
9
type BlindAlerter interface {
10
ScheduleAlertAt(duration time.Duration, amount int)
11
}
12
13
type BlindAlerterFunc func(duration time.Duration, amount int)
14
15
func (a BlindAlerterFunc) ScheduleAlertAt(duration time.Duration, amount int) {
16
a(duration, amount)
17
}
18
19
func StdOutAlerter(duration time.Duration, amount int) {
20
time.AfterFunc(duration, func() {
21
fmt.Fprintf(os.Stdout, "Blind is now %d\n", amount)
22
})
23
}
Copied!
Remember that any type can implement an interface, not just
structs. If you are making a library that exposes an interface with one function defined it is a common idiom to also expose a MyInterfaceFunc type.This type will be a
func which will also implement your interface. That way users of your interface have the option to implement your interface with just a function; rather than having to create an empty struct type.We then create the function
StdOutAlerter which has the same signature as the function and just use time.AfterFunc to schedule it to print to os.Stdout.Update
main where we create NewCLI to see this in action1
poker.NewCLI(store, os.Stdin, poker.BlindAlerterFunc(poker.StdOutAlerter)).PlayPoker()
Copied!
Before running you might want to change the
blindTime increment in CLI to be 10 seconds rather than 10 minutes just so you can see it in action.You should see it print the blind values as we'd expect every 10 seconds. Notice how you can still type
Shaun wins into the CLI and it will stop the program how we'd expect.The game wont always be played with 5 people so we need to prompt the user to enter a number of players before the game starts.
Write the test first
To check we are prompting for the number of players we'll want to record what is written to StdOut. We've done this a few times now, we know that
os.Stdout is an io.Writer so we can check what is written if we use dependency injection to pass in a bytes.Buffer in our test and see what our code will write.We don't care about our other collaborators in this test just yet so we've made some dummies in our test file.
We should be a little wary that we now have 4 dependencies for
CLI, that feels like maybe it is starting to have too many responsibilities. Let's live with it for now and see if a refactoring emerges as we add this new functionality.1
var dummyBlindAlerter = &SpyBlindAlerter{}
2
var dummyPlayerStore = &poker.StubPlayerStore{}
3
var dummyStdIn = &bytes.Buffer{}
4
var dummyStdOut = &bytes.Buffer{}
Copied!
Here is our new test
1
t.Run("it prompts the user to enter the number of players", func(t *testing.T) {
2
stdout := &bytes.Buffer{}
3
cli := poker.NewCLI(dummyPlayerStore, dummyStdIn, stdout, dummyBlindAlerter)
4
cli.PlayPoker()
5
6
got := stdout.String()
7
want := "Please enter the number of players: "
8
9
if got != want {
10
t.Errorf("got '%s', want '%s'", got, want)
11
}
12
})
Copied!
We pass in what will be
os.Stdout in main and see what is written.Try to run the test
1
./CLI_test.go:38:27: too many arguments in call to poker.NewCLI
2
have (*poker.StubPlayerStore, *bytes.Buffer, *bytes.Buffer, *SpyBlindAlerter)
3
want (poker.PlayerStore, io.Reader, poker.BlindAlerter)
Copied!
Write the minimal amount of code for the test to run and check the failing test output
We have a new dependency so we'll have to update
NewCLI1
func NewCLI(store PlayerStore, in io.Reader, out io.Writer, alerter BlindAlerter) *CLI
Copied!
Now the other tests will fail to compile because they dont have an
io.Writer being passed into NewCLI.Add
dummyStdout for the other tests.The new test should fail like so
1
=== RUN TestCLI
2
--- FAIL: TestCLI (0.00s)
3
=== RUN TestCLI/it_prompts_the_user_to_enter_the_number_of_players
4
--- FAIL: TestCLI/it_prompts_the_user_to_enter_the_number_of_players (0.00s)
5
CLI_test.go:46: got '', want 'Please enter the number of players: '
6
FAIL
Copied!
Write enough code to make it pass
We need to add our new dependency to our
CLI so we can reference it in PlayPoker1
type CLI struct {
2
playerStore PlayerStore
3
in *bufio.Reader
4
out io.Writer
5
alerter BlindAlerter
6
}
7
8
func NewCLI(store PlayerStore, in io.Reader, out io.Writer, alerter BlindAlerter) *CLI {
9
return &CLI{
10
playerStore: store,
11
in: bufio.NewReader(in),
12
out: out,
13
alerter: alerter,
14
}
15
}
Copied!
Then finally we can write our prompt at the start of the game
1
func (cli *CLI) PlayPoker() {
2
fmt.Fprint(cli.out, "Please enter the number of players: ")
3
cli.scheduleBlindAlerts()
4
userInput := cli.readLine()
5
cli.playerStore.RecordWin(extractWinner(userInput))
6
}
Copied!
Refactor
We have a duplicate string for the prompt which we should extract into a constant
1
const PlayerPrompt = "Please enter the number of players: "
Copied!
Use this in both the test code and
CLI.Now we need to send in a number and extract it out. The only way we'll know if it has had the desired effect is by seeing what blind alerts were scheduled.
Write the test first
1
t.Run("it prompts the user to enter the number of players", func(t *testing.T) {
2
stdout := &bytes.Buffer{}
3
in := strings.NewReader("7\n")
4
blindAlerter := &SpyBlindAlerter{}
5
6
cli := poker.NewCLI(dummyPlayerStore, in, stdout, blindAlerter)
7
cli.PlayPoker()
8
9
got :=stdout.String()
10
want := poker.PlayerPrompt
11
12
if got != want {
13
t.Errorf("got '%s', want '%s'", got, want)
14
}
15
16
cases := []scheduledAlert{
17
{0 * time.Second, 100},
18
{12 * time.Minute, 200},
19
{24 * time.Minute, 300},
20
{36 * time.Minute, 400},
21
}
22
23
for i, want := range cases {
24
t.Run(fmt.Sprint(want), func(t *testing.T) {
25
26
if len(blindAlerter.alerts) <= i {
27
t.Fatalf("alert %d was not scheduled %v", i, blindAlerter.alerts)
28
}
29
30
got := blindAlerter.alerts[i]
31
assertScheduledAlert(t, got, want)
32
})
33
}
34
})
Copied!
Ouch! A lot of changes.
- We remove our dummy for StdIn and instead send in a mocked version representing our user entering 7
- We also remove our dummy on the blind alerter so we can see that the number of players has had an effect on the scheduling
- We test what alerts are scheduled
Try to run the test
The test should still compile and fail reporting that the scheduled times are wrong because we've hard-coded for the game to be based on having 5 players
1
=== RUN TestCLI
2
--- FAIL: TestCLI (0.00s)
3
=== RUN TestCLI/it_prompts_the_user_to_enter_the_number_of_players
4
--- FAIL: TestCLI/it_prompts_the_user_to_enter_the_number_of_players (0.00s)
5
=== RUN TestCLI/it_prompts_the_user_to_enter_the_number_of_players/100_chips_at_0s
6
--- PASS: TestCLI/it_prompts_the_user_to_enter_the_number_of_players/100_chips_at_0s (0.00s)
7
=== RUN TestCLI/it_prompts_the_user_to_enter_the_number_of_players/200_chips_at_12m0s
Copied!
Write enough code to make it pass
Remember, we are free to commit whatever sins we need to make this work. Once we have working software we can then work on refactoring the mess we're about to make!
1
func (cli *CLI) PlayPoker() {
2
fmt.Fprint(cli.out, PlayerPrompt)
3
4
numberOfPlayers, _ := strconv.Atoi(cli.readLine())
5
6
cli.scheduleBlindAlerts(numberOfPlayers)
7
8
userInput := cli.readLine()
9
cli.playerStore.RecordWin(extractWinner(userInput))
10
}
11
12
func (cli *CLI) scheduleBlindAlerts(numberOfPlayers int) {
13
blindIncrement := time.Duration(5 + numberOfPlayers) * time.Minute
14
15
blinds := []int{100, 200, 300, 400, 500, 600, 800, 1000, 2000, 4000, 8000}
16
blindTime := 0 * time.Second
17
for _, blind := range blinds {
18
cli.alerter.ScheduleAlertAt(blindTime, blind)
19
blindTime = blindTime + blindIncrement
20
}
21
}
Copied!
- We read in the
numberOfPlayersInputinto a string - We use
cli.readLine()to get the input from the user and then callAtoito convert it into an integer - ignoring any error scenarios. We'll need to write a test for that scenario later. - From here we change
scheduleBlindAlertsto accept a number of players. We then calculate ablindIncrementtime to use to add toblindTimeas we iterate over the blind amounts
While our new test has been fixed, a lot of others have failed because now our system only works if the game starts with a user entering a number. You'll need to fix the tests by changing the user inputs so that a number followed by a newline is added (this is highlighting yet more flaws in our approach right now).
Refactor
This all feels a bit horrible right? Let's listen to our tests.
- In order to test that we are scheduling some alerts we set up 4 different dependencies. Whenever you have a lot of dependencies for a thing in your system, it implies it's doing too much. Visually we can see it in how cluttered our test is.
- To me it feels like we need to make a cleaner abstraction between reading user input and the business logic we want to do
- A better test would be given this user input, do we call a new type
Gamewith the correct number of players. - We would then extract the testing of the scheduling into the tests for our new
Game.
We can refactor toward our
Game first and our test should continue to pass. Once we've made the structural changes we want we can think about how we can refactor the tests to reflect our new separation of concernsRemember when making changes in refactoring try to keep them as small as possible and keep re-running the tests.
Try it yourself first. Think about the boundaries of what a
Game would offer and what our CLI should be doing.For now don't change the external interface of
NewCLI as we don't want to change the test code and the client code at the same time as that is too much to juggle and we could end up breaking things.This is what I came up with:
1
// game.go
2
type Game struct {
3
alerter BlindAlerter
4
store PlayerStore
5
}
6
7
func (p *Game) Start(numberOfPlayers int) {
8
blindIncrement := time.Duration(5+numberOfPlayers) * time.Minute
9
10
blinds := []int{100, 200, 300, 400, 500, 600, 800, 1000, 2000, 4000, 8000}
11
blindTime := 0 * time.Second
12
for _, blind := range blinds {
13
p.alerter.ScheduleAlertAt(blindTime, blind)
14
blindTime = blindTime + blindIncrement
15
}
16
}
17
18
func (p *Game) Finish(winner string) {
19
p.store.RecordWin(winner)
20
}
21
22
// cli.go
23
type CLI struct {
24
playerStore PlayerStore
25
in *bufio.Reader
26
out io.Writer
27
game *Game
28
}
29
30
func NewCLI(store PlayerStore, in io.Reader, out io.Writer, alerter BlindAlerter) *CLI {
31
return &CLI{
32
in: bufio.NewReader(in),
33
out: out,
34
game: &Game{
35
alerter: alerter,
36
store: store,
37
},
38
}
39
}
40
41
const PlayerPrompt = "Please enter the number of players: "
42
43
func (cli *CLI) PlayPoker() {
44
fmt.Fprint(cli.out, PlayerPrompt)
45
46
numberOfPlayersInput := cli.readLine()
47
numberOfPlayers, _ := strconv.Atoi(strings.Trim(numberOfPlayersInput, "\n"))
48
49
cli.game.Start(numberOfPlayers)
50
51
winnerInput := cli.readLine()
52
winner := extractWinner(winnerInput)
53
54
cli.game.Finish(winner)
55
}
56
57
func extractWinner(userInput string) string {
58
return strings.Replace(userInput, " wins\n", "", 1)
59
}
60
61
func (cli *CLI) readLine() string {
62
cli.in.Scan()
63
return cli.in.Text()
64
}
Copied!
From a "domain" perspective:
- We want to
StartaGame, indicating how many people are playing - We want to
FinishaGame, declaring the winner
The new
Game type encapsulates this for us.With this change we've passed
BlindAlerter and PlayerStore to Game as it is now responsible for alerting and storing results.Our
CLI is now just concerned with:- Constructing
Gamewith its existing dependencies (which we'll refactor next) - Interpreting user input as method invocations for
Game
We want to try to avoid doing "big" refactors which leave us in a state of failing tests for extended periods as that increases the chances of mistakes. (If you are working in a large/distributed team this is extra important)
The first thing we'll do is refactor
Game so that we inject it into CLI. We'll do the smallest changes in our tests to facilitate that and then we'll see how we can break up the tests into the themes of parsing user input and game management.All we need to do right now is change
NewCLI1
func NewCLI(in io.Reader, out io.Writer, game *Game) *CLI {
2
return &CLI{
3
in: bufio.NewReader(in),
4
out: out,
5
game: game,
6
}
7
}
Copied!
This feels like an improvement already. We have less dependencies and our dependency list is reflecting our overall design goal of CLI being concerned with input/output and delegating game specific actions to a
Game.If you try and compile there are problems. You should be able to fix these problems yourself. Don't worry about making any mocks for
Game right now, just initialise real Games just to get everything compiling and tests green.To do this you'll need to make a constructor
1
func NewGame(alerter BlindAlerter, store PlayerStore) *Game {
2
return &Game{
3
alerter:alerter,
4
store:store,
5
}
6
}
Copied!
Here's an example of one of the setups for the tests being fixed
1
stdout := &bytes.Buffer{}
2
in := strings.NewReader("7\n")
3
blindAlerter := &SpyBlindAlerter{}
4
game := poker.NewGame(blindAlerter, dummyPlayerStore)
5
6
cli := poker.NewCLI(in, stdout, game)
7
cli.PlayPoker()
Copied!
It shouldn't take much effort to fix the tests and be back to green again (that's the point!) but make sure you fix
main.go too before the next stage.1
// main.go
2
game := poker.NewGame(poker.BlindAlerterFunc(poker.StdOutAlerter), store)
3
cli := poker.NewCLI(os.Stdin, os.Stdout, game)
4
cli.PlayPoker()
Copied!
Now that we have extracted out
Game we should move our game specific assertions into tests separate from CLI.This is just an exercise in copying our
CLI tests but with less dependencies1
func TestGame_Start(t *testing.T) {
2
t.Run("schedules alerts on game start for 5 players", func(t *testing.T) {
3
blindAlerter := &poker.SpyBlindAlerter{}
4
game := poker.NewTexasHoldem(blindAlerter, dummyPlayerStore)
5
6
game.Start(5)
7
8
cases := []poker.ScheduledAlert{
9
{At: 0 * time.Second, Amount: 100},
10
{At: 10 * time.Minute, Amount: 200},
11
{At: 20 * time.Minute, Amount: 300},
12
{At: 30 * time.Minute, Amount: 400},
13
{At: 40 * time.Minute, Amount: 500},
14
{At: 50 * time.Minute, Amount: 600},
15
{At: 60 * time.Minute, Amount: 800},
16
{At: 70 * time.Minute, Amount: 1000},
17
{At: 80 * time.Minute, Amount: 2000},
18
{At: 90 * time.Minute, Amount: 4000},
19
{At: 100 * time.Minute, Amount: 8000},
20
}
21
22
checkSchedulingCases(cases, t, blindAlerter)
23
})
24
25
t.Run("schedules alerts on game start for 7 players", func(t *testing.T) {
26
blindAlerter := &poker.SpyBlindAlerter{}
27
game := poker.NewTexasHoldem(blindAlerter, dummyPlayerStore)
28
29
game.Start(7)
30
31
cases := []poker.ScheduledAlert{
32
{At: 0 * time.Second, Amount: 100},
33
{At: 12 * time.Minute, Amount: 200},
34
{At: 24 * time.Minute, Amount: 300},
35
{At: 36 * time.Minute, Amount: 400},
36
}
37
38
checkSchedulingCases(cases, t, blindAlerter)
39
})
40
41
}
42
43
func TestGame_Finish(t *testing.T) {
44
store := &poker.StubPlayerStore{}
45
game := poker.NewTexasHoldem(dummyBlindAlerter, store)
46
winner := "Ruth"
47
48
game.Finish(winner)
49
poker.AssertPlayerWin(t, store, winner)
50
}
Copied!
The intent behind what happens when a game of poker starts is now much clearer.
Make sure to also move over the test for when the game ends.
Once we are happy we have moved the tests over for game logic we can simplify our CLI tests so they reflect our intended responsibilities clearer
- Process user input and call
Game's methods when appropriate - Send output
- Crucially it doesn't know about the actual workings of how games work
To do this we'll have to make it so
CLI no longer relies on a concrete Game type but instead accepts an interface with Start(numberOfPlayers) and Finish(winner). We can then create a spy of that type and verify the correct calls are made.It's here we realise that naming is awkward sometimes. Rename
Game to TexasHoldem (as that's the kind of game we're playing) and the new interface will be called Game. This keeps faithful to the notion that our CLI is oblivious to the actual game we're playing and what happens when you Start and Finish.1
type Game interface {
2
Start(numberOfPlayers int)
3
Finish(winner string)
4
}
Copied!
Replace all references to
*Game inside CLI and replace them with Game (our new interface). As always keep re-running tests to check everything is green while we are refactoring.Now that we have decoupled
CLI from TexasHoldem we can use spies to check that Start and Finish are called when we expect them to, with the correct arguments.Create a spy that implements
Game1
type GameSpy struct {
2
StartedWith int
3
FinishedWith string
4
}
5
6
func (g *GameSpy) Start(numberOfPlayers int) {
7
g.StartedWith = numberOfPlayers
8
}
9
10
func (g *GameSpy) Finish(winner string) {
11
g.FinishedWith = winner
12
}
Copied!
Replace any
CLI test which is testing any game specific logic with checks on how our GameSpy is called. This will then reflect the responsibilities of CLI in our tests clearly.Here is an example of one of the tests being fixed; try and do the rest yourself and check the source code if you get stuck.
1
t.Run("it prompts the user to enter the number of players and starts the game", func(t *testing.T) {
2
stdout := &bytes.Buffer{}
3
in := strings.NewReader("7\n")
4
game := &GameSpy{}
5
6
cli := poker.NewCLI(in, stdout, game)
7
cli.PlayPoker()
8
9
gotPrompt := stdout.String()
10
wantPrompt := poker.PlayerPrompt
11
12
if gotPrompt != wantPrompt {
13
t.Errorf("got '%s', want '%s'", gotPrompt, wantPrompt)
14
}
15
16
if game.StartCalledWith != 7 {
17
t.Errorf("wanted Start called with 7 but got %d", game.StartCalledWith)
18
}
19
})
Copied!
Now that we have a clean separation of concerns, checking edge cases around IO in our
CLI should be easier.We need to address the scenario where a user puts a non numeric value when prompted for the number of players:
Our code should not start the game and it should print a handy error to the user and then exit.
Write the test first
We'll start by making sure the game doesn't start
1
t.Run("it prints an error when a non numeric value is entered and does not start the game", func(t *testing.T) {
2
stdout := &bytes.Buffer{}
3
in := strings.NewReader("Pies\n")
4
game := &GameSpy{}
5
6
cli := poker.NewCLI(in, stdout, game)
7
cli.PlayPoker()
8
9
if game.StartCalled {
10
t.Errorf("game should not have started")
11
}
12
})
Copied!
You'll need to add to our
GameSpy a field StartCalled which only gets set if Start is calledTry to run the test
1
=== RUN TestCLI/it_prints_an_error_when_a_non_numeric_value_is_entered_and_does_not_start_the_game
2
--- FAIL: TestCLI/it_prints_an_error_when_a_non_numeric_value_is_entered_and_does_not_start_the_game (0.00s)
3
CLI_test.go:62: game should not have started
Copied!
Write enough code to make it pass
Around where we call
Atoi we just need to check for the error1
numberOfPlayers, err := strconv.Atoi(cli.readLine())
2
3
if err != nil {
4
return
5
}
Copied!
Next we need to inform the user of what they did wrong so we'll assert on what is printed to
stdout.Write the test first
We've asserted on what was printed to
stdout before so we can copy that code for now1
gotPrompt := stdout.String()
2
3
wantPrompt := poker.PlayerPrompt + "you're so silly"
4
5
if gotPrompt != wantPrompt {
6
t.Errorf("got '%s', want '%s'", gotPrompt, wantPrompt)
7
}
Copied!
We are storing everything that gets written to stdout so we still expect the
poker.PlayerPrompt. We then just check an additional thing gets printed. We're not too bothered about the exact wording for now, we'll address it when we refactor.Try to run the test
1
=== RUN TestCLI/it_prints_an_error_when_a_non_numeric_value_is_entered_and_does_not_start_the_game
2
--- FAIL: TestCLI/it_prints_an_error_when_a_non_numeric_value_is_entered_and_does_not_start_the_game (0.00s)
3
CLI_test.go:70: got 'Please enter the number of players: ', want 'Please enter the number of players: you're so silly'
Copied!
Write enough code to make it pass
Change the error handling code
1
if err != nil {
2
fmt.Fprint(cli.out, "you're so silly")
3
return
4
}
Copied!
Refactor
Now refactor the message into a constant like
PlayerPrompt1
wantPrompt := poker.PlayerPrompt + poker.BadPlayerInputErrMsg
Copied!
and put in a more appropriate message
1
const BadPlayerInputErrMsg = "Bad value received for number of players, please try again with a number"
Copied!
Finally our testing around what has been sent to
stdout is quite verbose, let's write an assert function to clean it up.1
func assertMessagesSentToUser(t *testing.T, stdout *bytes.Buffer, messages ...string) {
2
t.Helper()
3
want := strings.Join(messages, "")
4
got := stdout.String()
5
if got != want {
6
t.Errorf("got '%s' sent to stdout but expected %+v", got, messages)
7
}
8
}
Copied!
Using the vararg syntax (
...string) is handy here because we need to assert on varying amounts of messages.Use this helper in both of the tests where we assert on messages sent to the user.
There are a number of tests that could be helped with some
assertX functions so practice your refactoring by cleaning up our tests so they read nicely.Take some time and think about the value of some of the tests we've driven out. Remember we don't want more tests than necessary, can you refactor/remove some of them and still be confident it all works ?
Here is what I came up with
1
func TestCLI(t *testing.T) {
2
3
t.Run("start game with 3 players and finish game with 'Chris' as winner", func(t *testing.T) {
4
game := &GameSpy{}
5
stdout := &bytes.Buffer{}
6
7
in := userSends("3", "Chris wins")
8