diff --git a/README.md b/README.md
index 75d2f127..86fe0302 100644
--- a/README.md
+++ b/README.md
@@ -30,7 +30,7 @@
 7. [Ponteiros e erros](primeiros-passos-com-go/pointers-and-errors.md) - Aprenda sobre ponteiros e erros.
 8. [Maps](primeiros-passos-com-go/maps.md) - Aprenda sobre armazenamento de valores na estrutura de dados `map`.
 9. [Injeção de dependência](primeiros-passos-com-go/dependency-injection.md) - Aprenda sobre injeção de dependência, qual sua relação com interfaces e uma introdução a I/O.
-10. [Mocking](primeiros-passos-com-go/mocking.md) - Use injeção de dependência com mocking para testar um código sem nenhum teste.
+10. [Mocking](primeiros-passos-com-go/mocks.md) - Use injeção de dependência com mocking para testar um código sem nenhum teste.
 11. [Concorrência](primeiros-passos-com-go/concurrency.md) - Aprenda como escrever código concorrente para tornar seu software mais rápido.
 12. [Select](primeiros-passos-com-go/select.md) - Aprenda a sincronizar processos assíncronos de forma elegante.
 13. [Reflection](primeiros-passos-com-go/reflection.md) - Aprenda sobre reflection.
diff --git a/SUMMARY.md b/SUMMARY.md
index a07d384e..cfd77301 100644
--- a/SUMMARY.md
+++ b/SUMMARY.md
@@ -14,7 +14,7 @@
 -   [Ponteiros e erros](primeiros-passos-com-go/pointers-and-errors.md)
 -   [Maps](primeiros-passos-com-go/maps.md)
 -   [Injeção de dependência](primeiros-passos-com-go/dependency-injection.md)
--   [Mocking](primeiros-passos-com-go/mocking.md)
+-   [Mocking](primeiros-passos-com-go/mocks.md)
 -   [Concorrência](primeiros-passos-com-go/concurrency.md)
 -   [Select](primeiros-passos-com-go/select.md)
 -   [Reflection](primeiros-passos-com-go/reflection.md)
diff --git a/build.books.sh b/build.books.sh
index b61a5630..4bca0f3b 100755
--- a/build.books.sh
+++ b/build.books.sh
@@ -14,7 +14,7 @@ docker run -v `pwd`:/source jagregory/pandoc -o aprenda-go-com-testes.pdf --late
     primeiros-passos-com-go/pointers-and-errors.md \
     primeiros-passos-com-go/maps.md \
     primeiros-passos-com-go/injecao-de-dependencia.md \
-    primeiros-passos-com-go/mocking.md \
+    primeiros-passos-com-go/mocks.md \
     primeiros-passos-com-go/concurrency.md \
     primeiros-passos-com-go/select.md \
     primeiros-passos-com-go/reflection.md \
@@ -42,7 +42,7 @@ docker run -v `pwd`:/source jagregory/pandoc -o aprenda-go-com-testes.epub --lat
     primeiros-passos-com-go/pointers-and-errors.md \
     primeiros-passos-com-go/maps.md \
     primeiros-passos-com-go/injecao-de-dependencia.md \
-    primeiros-passos-com-go/mocking.md \
+    primeiros-passos-com-go/mocks.md \
     primeiros-passos-com-go/concurrency.md \
     primeiros-passos-com-go/select.md \
     primeiros-passos-com-go/reflection.md \
diff --git a/mocking/v1/countdown_test.go b/mocking/v1/countdown_test.go
deleted file mode 100644
index affb9dc1..00000000
--- a/mocking/v1/countdown_test.go
+++ /dev/null
@@ -1,19 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"testing"
-)
-
-func TestCountdown(t *testing.T) {
-	buffer := &bytes.Buffer{}
-
-	Countdown(buffer)
-
-	got := buffer.String()
-	want := "3"
-
-	if got != want {
-		t.Errorf("got '%s' want '%s'", got, want)
-	}
-}
diff --git a/mocking/v1/main.go b/mocking/v1/main.go
deleted file mode 100644
index 4613c0a6..00000000
--- a/mocking/v1/main.go
+++ /dev/null
@@ -1,16 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"io"
-	"os"
-)
-
-// Countdown prints a countdown from 5 to out
-func Countdown(out io.Writer) {
-	fmt.Fprint(out, "3")
-}
-
-func main() {
-	Countdown(os.Stdout)
-}
diff --git a/mocking/v2/countdown_test.go b/mocking/v2/countdown_test.go
deleted file mode 100644
index a9a53d3c..00000000
--- a/mocking/v2/countdown_test.go
+++ /dev/null
@@ -1,22 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"testing"
-)
-
-func TestCountdown(t *testing.T) {
-	buffer := &bytes.Buffer{}
-
-	Countdown(buffer)
-
-	got := buffer.String()
-	want := `3
-2
-1
-Go!`
-
-	if got != want {
-		t.Errorf("got '%s' want '%s'", got, want)
-	}
-}
diff --git a/mocking/v2/main.go b/mocking/v2/main.go
deleted file mode 100644
index c78301d0..00000000
--- a/mocking/v2/main.go
+++ /dev/null
@@ -1,22 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"io"
-	"os"
-)
-
-const finalWord = "Go!"
-const countdownStart = 3
-
-// Countdown prints a countdown from 5 to out
-func Countdown(out io.Writer) {
-	for i := countdownStart; i > 0; i-- {
-		fmt.Fprintln(out, i)
-	}
-	fmt.Fprint(out, finalWord)
-}
-
-func main() {
-	Countdown(os.Stdout)
-}
diff --git a/mocking/v3/countdown_test.go b/mocking/v3/countdown_test.go
deleted file mode 100644
index ad93233b..00000000
--- a/mocking/v3/countdown_test.go
+++ /dev/null
@@ -1,35 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"testing"
-)
-
-func TestCountdown(t *testing.T) {
-	buffer := &bytes.Buffer{}
-	spySleeper := &SpySleeper{}
-
-	Countdown(buffer, spySleeper)
-
-	got := buffer.String()
-	want := `3
-2
-1
-Go!`
-
-	if got != want {
-		t.Errorf("got '%s' want '%s'", got, want)
-	}
-
-	if spySleeper.Calls != 4 {
-		t.Errorf("not enough calls to sleeper, want 4 got %d", spySleeper.Calls)
-	}
-}
-
-type SpySleeper struct {
-	Calls int
-}
-
-func (s *SpySleeper) Sleep() {
-	s.Calls++
-}
diff --git a/mocking/v3/main.go b/mocking/v3/main.go
deleted file mode 100644
index 1957f126..00000000
--- a/mocking/v3/main.go
+++ /dev/null
@@ -1,40 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"io"
-	"os"
-	"time"
-)
-
-// Sleeper allows you to put delays
-type Sleeper interface {
-	Sleep()
-}
-
-// DefaultSleeper is an implementation of Sleeper with a predefined delay
-type DefaultSleeper struct{}
-
-// Sleep will pause execution for the defined Duration
-func (d *DefaultSleeper) Sleep() {
-	time.Sleep(1 * time.Second)
-}
-
-const finalWord = "Go!"
-const countdownStart = 3
-
-// Countdown prints a countdown from 5 to out with a delay between count provided by Sleeper
-func Countdown(out io.Writer, sleeper Sleeper) {
-	for i := countdownStart; i > 0; i-- {
-		sleeper.Sleep()
-		fmt.Fprintln(out, i)
-	}
-
-	sleeper.Sleep()
-	fmt.Fprint(out, finalWord)
-}
-
-func main() {
-	sleeper := &DefaultSleeper{}
-	Countdown(os.Stdout, sleeper)
-}
diff --git a/mocking/v4/countdown_test.go b/mocking/v4/countdown_test.go
deleted file mode 100644
index 3ae7a7d4..00000000
--- a/mocking/v4/countdown_test.go
+++ /dev/null
@@ -1,61 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"reflect"
-	"testing"
-)
-
-func TestCountdown(t *testing.T) {
-
-	t.Run("prints 5 to Go!", func(t *testing.T) {
-		buffer := &bytes.Buffer{}
-		Countdown(buffer, &CountdownOperationsSpy{})
-
-		got := buffer.String()
-		want := `3
-2
-1
-Go!`
-
-		if got != want {
-			t.Errorf("got '%s' want '%s'", got, want)
-		}
-	})
-
-	t.Run("sleep before every print", func(t *testing.T) {
-		spySleepPrinter := &CountdownOperationsSpy{}
-		Countdown(spySleepPrinter, spySleepPrinter)
-
-		want := []string{
-			sleep,
-			write,
-			sleep,
-			write,
-			sleep,
-			write,
-			sleep,
-			write,
-		}
-
-		if !reflect.DeepEqual(want, spySleepPrinter.Calls) {
-			t.Errorf("wanted calls %v got %v", want, spySleepPrinter.Calls)
-		}
-	})
-}
-
-type CountdownOperationsSpy struct {
-	Calls []string
-}
-
-func (s *CountdownOperationsSpy) Sleep() {
-	s.Calls = append(s.Calls, sleep)
-}
-
-func (s *CountdownOperationsSpy) Write(p []byte) (n int, err error) {
-	s.Calls = append(s.Calls, write)
-	return
-}
-
-const write = "write"
-const sleep = "sleep"
diff --git a/mocking/v4/main.go b/mocking/v4/main.go
deleted file mode 100644
index c943e7a5..00000000
--- a/mocking/v4/main.go
+++ /dev/null
@@ -1,41 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"io"
-	"os"
-	"time"
-)
-
-// Sleeper allows you to put delays
-type Sleeper interface {
-	Sleep()
-}
-
-// DefaultSleeper is an implementation of Sleeper with a predefined delay
-type DefaultSleeper struct{}
-
-// Sleep will pause execution for the defined Duration
-func (d *DefaultSleeper) Sleep() {
-	time.Sleep(1 * time.Second)
-}
-
-const finalWord = "Go!"
-const countdownStart = 3
-
-// Countdown prints a countdown from 5 to out with a delay between count provided by Sleeper
-func Countdown(out io.Writer, sleeper Sleeper) {
-
-	for i := countdownStart; i > 0; i-- {
-		sleeper.Sleep()
-		fmt.Fprintln(out, i)
-	}
-
-	sleeper.Sleep()
-	fmt.Fprint(out, finalWord)
-}
-
-func main() {
-	sleeper := &DefaultSleeper{}
-	Countdown(os.Stdout, sleeper)
-}
diff --git a/mocking/v5/countdown_test.go b/mocking/v5/countdown_test.go
deleted file mode 100644
index c5be19ee..00000000
--- a/mocking/v5/countdown_test.go
+++ /dev/null
@@ -1,82 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"reflect"
-	"testing"
-	"time"
-)
-
-func TestCountdown(t *testing.T) {
-
-	t.Run("prints 5 to Go!", func(t *testing.T) {
-		buffer := &bytes.Buffer{}
-		Countdown(buffer, &CountdownOperationsSpy{})
-
-		got := buffer.String()
-		want := `3
-2
-1
-Go!`
-
-		if got != want {
-			t.Errorf("got '%s' want '%s'", got, want)
-		}
-	})
-
-	t.Run("sleep before every print", func(t *testing.T) {
-		spySleepPrinter := &CountdownOperationsSpy{}
-		Countdown(spySleepPrinter, spySleepPrinter)
-
-		want := []string{
-			sleep,
-			write,
-			sleep,
-			write,
-			sleep,
-			write,
-			sleep,
-			write,
-		}
-
-		if !reflect.DeepEqual(want, spySleepPrinter.Calls) {
-			t.Errorf("wanted calls %v got %v", want, spySleepPrinter.Calls)
-		}
-	})
-}
-
-func TestConfigurableSleeper(t *testing.T) {
-	sleepTime := 5 * time.Second
-
-	spyTime := &SpyTime{}
-	sleeper := ConfigurableSleeper{sleepTime, spyTime.Sleep}
-	sleeper.Sleep()
-
-	if spyTime.durationSlept != sleepTime {
-		t.Errorf("should have slept for %v but slept for %v", sleepTime, spyTime.durationSlept)
-	}
-}
-
-type CountdownOperationsSpy struct {
-	Calls []string
-}
-
-func (s *CountdownOperationsSpy) Sleep() {
-	s.Calls = append(s.Calls, sleep)
-}
-
-func (s *CountdownOperationsSpy) Write(p []byte) (n int, err error) {
-	s.Calls = append(s.Calls, write)
-	return
-}
-
-const write = "write"
-const sleep = "sleep"
-
-type SpyTime struct {
-	durationSlept time.Duration
-}
-
-func (s *SpyTime) Sleep(duration time.Duration) {
-	s.durationSlept = duration
-}
diff --git a/mocking/v5/main.go b/mocking/v5/main.go
deleted file mode 100644
index 940b7e55..00000000
--- a/mocking/v5/main.go
+++ /dev/null
@@ -1,44 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"io"
-	"os"
-	"time"
-)
-
-// Sleeper allows you to put delays
-type Sleeper interface {
-	Sleep()
-}
-
-// ConfigurableSleeper is an implementation of Sleeper with a defined delay
-type ConfigurableSleeper struct {
-	duration time.Duration
-	sleep    func(time.Duration)
-}
-
-// Sleep will pause execution for the defined Duration
-func (c *ConfigurableSleeper) Sleep() {
-	c.sleep(c.duration)
-}
-
-const finalWord = "Go!"
-const countdownStart = 3
-
-// Countdown prints a countdown from 5 to out with a delay between count provided by Sleeper
-func Countdown(out io.Writer, sleeper Sleeper) {
-
-	for i := countdownStart; i > 0; i-- {
-		sleeper.Sleep()
-		fmt.Fprintln(out, i)
-	}
-
-	sleeper.Sleep()
-	fmt.Fprint(out, finalWord)
-}
-
-func main() {
-	sleeper := &ConfigurableSleeper{1 * time.Second, time.Sleep}
-	Countdown(os.Stdout, sleeper)
-}
diff --git a/mocks/v1/contagem_test.go b/mocks/v1/contagem_test.go
new file mode 100644
index 00000000..e75f9227
--- /dev/null
+++ b/mocks/v1/contagem_test.go
@@ -0,0 +1,19 @@
+package main
+
+import (
+	"bytes"
+	"testing"
+)
+
+func TestContagem(t *testing.T) {
+	buffer := &bytes.Buffer{}
+
+	Contagem(buffer)
+
+	resultado := buffer.String()
+	esperado := "3"
+
+	if resultado != esperado {
+		t.Errorf("resultado '%s', esperado '%s'", resultado, esperado)
+	}
+}
diff --git a/mocks/v1/main.go b/mocks/v1/main.go
new file mode 100644
index 00000000..71bea0fc
--- /dev/null
+++ b/mocks/v1/main.go
@@ -0,0 +1,16 @@
+package main
+
+import (
+	"fmt"
+	"io"
+	"os"
+)
+
+// Contagem imprime uma contagem de 3 para a saída
+func Contagem(saida io.Writer) {
+	fmt.Fprint(saida, "3")
+}
+
+func main() {
+	Contagem(os.Stdout)
+}
diff --git a/mocks/v2/contagem_test.go b/mocks/v2/contagem_test.go
new file mode 100644
index 00000000..6ac583b1
--- /dev/null
+++ b/mocks/v2/contagem_test.go
@@ -0,0 +1,21 @@
+package main
+
+import (
+	"bytes"
+	"testing"
+)
+
+func TestContagem(t *testing.T) {
+	buffer := &bytes.Buffer{}
+
+	Contagem(buffer)
+
+	resultado := buffer.String()
+	esperado := `3
+2
+1
+Vai!`
+	if resultado != esperado {
+		t.Errorf("resultado '%s', esperado '%s'", resultado, esperado)
+	}
+}
diff --git a/mocks/v2/main.go b/mocks/v2/main.go
new file mode 100644
index 00000000..e71a1ea0
--- /dev/null
+++ b/mocks/v2/main.go
@@ -0,0 +1,22 @@
+package main
+
+import (
+	"fmt"
+	"io"
+	"os"
+)
+
+const ultimaPalavra = "Vai!"
+const inicioContagem = 3
+
+// Contagem imprime uma contagem de 3 para a saída
+func Contagem(saida io.Writer) {
+	for i := inicioContagem; i > 0; i-- {
+		fmt.Fprintln(saida, i)
+	}
+	fmt.Fprint(saida, ultimaPalavra)
+}
+
+func main() {
+	Contagem(os.Stdout)
+}
diff --git a/mocks/v3/contagem_test.go b/mocks/v3/contagem_test.go
new file mode 100644
index 00000000..37a53ad8
--- /dev/null
+++ b/mocks/v3/contagem_test.go
@@ -0,0 +1,35 @@
+package main
+
+import (
+	"bytes"
+	"testing"
+)
+
+func TestContagem(t *testing.T) {
+	buffer := &bytes.Buffer{}
+	sleeperSpy := &SleeperSpy{}
+
+	Contagem(buffer, sleeperSpy)
+
+	resultado := buffer.String()
+	esperado := `3
+2
+1
+Vai!`
+
+	if resultado != esperado {
+		t.Errorf("resultado '%s', esperado '%s'", resultado, esperado)
+	}
+
+	if sleeperSpy.Chamadas != 4 {
+		t.Errorf("não houve chamadas suficientes do sleeper, esperado 4, resultado %d", sleeperSpy.Chamadas)
+	}
+}
+
+type SleeperSpy struct {
+	Chamadas int
+}
+
+func (s *SleeperSpy) Pausa() {
+	s.Chamadas++
+}
diff --git a/mocks/v3/main.go b/mocks/v3/main.go
new file mode 100644
index 00000000..8f0e78cd
--- /dev/null
+++ b/mocks/v3/main.go
@@ -0,0 +1,40 @@
+package main
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"time"
+)
+
+// Sleeper te permite definir pausas
+type Sleeper interface {
+	Pausa()
+}
+
+// SleeperPadrao é uma implementação de Sleeper com um atraso pré-definido
+type SleeperPadrao struct{}
+
+// Pausa vai pausar a execução pela Duração definida
+func (d *SleeperPadrao) Pausa() {
+	time.Sleep(1 * time.Second)
+}
+
+const ultimaPalavra = "Vai!"
+const inicioContagem = 3
+
+// Contagem imprime uma contagem de 3 para a saída com um atraso determinado por um Sleeper
+func Contagem(saida io.Writer, sleeper Sleeper) {
+	for i := inicioContagem; i > 0; i-- {
+		sleeper.Pausa()
+		fmt.Fprintln(saida, i)
+	}
+
+	sleeper.Pausa()
+	fmt.Fprint(saida, ultimaPalavra)
+}
+
+func main() {
+	sleeper := &SleeperPadrao{}
+	Contagem(os.Stdout, sleeper)
+}
diff --git a/mocks/v4/contagem_test.go b/mocks/v4/contagem_test.go
new file mode 100644
index 00000000..a1d60aed
--- /dev/null
+++ b/mocks/v4/contagem_test.go
@@ -0,0 +1,61 @@
+package main
+
+import (
+	"bytes"
+	"reflect"
+	"testing"
+)
+
+func TestContagem(t *testing.T) {
+
+	t.Run("imprime 3 até Vai!", func(t *testing.T) {
+		buffer := &bytes.Buffer{}
+		Contagem(buffer, &SpyContagemOperacoes{})
+
+		resultado := buffer.String()
+		esperado := `3
+2
+1
+Vai!`
+
+		if resultado != esperado {
+			t.Errorf("resultado '%s', esperado '%s'", resultado, esperado)
+		}
+	})
+
+	t.Run("pausa antes de cada impressão", func(t *testing.T) {
+		spyImpressoraSleep := &SpyContagemOperacoes{}
+		Contagem(spyImpressoraSleep, spyImpressoraSleep)
+
+		esperado := []string{
+			pausa,
+			escrita,
+			pausa,
+			escrita,
+			pausa,
+			escrita,
+			pausa,
+			escrita,
+		}
+
+		if !reflect.DeepEqual(esperado, spyImpressoraSleep.Chamadas) {
+			t.Errorf("esperado %v chamadas, resultado %v", esperado, spyImpressoraSleep.Chamadas)
+		}
+	})
+}
+
+type SpyContagemOperacoes struct {
+	Chamadas []string
+}
+
+func (s *SpyContagemOperacoes) Pausa() {
+	s.Chamadas = append(s.Chamadas, pausa)
+}
+
+func (s *SpyContagemOperacoes) Write(p []byte) (n int, err error) {
+	s.Chamadas = append(s.Chamadas, escrita)
+	return
+}
+
+const escrita = "escrita"
+const pausa = "pausa"
diff --git a/mocks/v4/main.go b/mocks/v4/main.go
new file mode 100644
index 00000000..8f0e78cd
--- /dev/null
+++ b/mocks/v4/main.go
@@ -0,0 +1,40 @@
+package main
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"time"
+)
+
+// Sleeper te permite definir pausas
+type Sleeper interface {
+	Pausa()
+}
+
+// SleeperPadrao é uma implementação de Sleeper com um atraso pré-definido
+type SleeperPadrao struct{}
+
+// Pausa vai pausar a execução pela Duração definida
+func (d *SleeperPadrao) Pausa() {
+	time.Sleep(1 * time.Second)
+}
+
+const ultimaPalavra = "Vai!"
+const inicioContagem = 3
+
+// Contagem imprime uma contagem de 3 para a saída com um atraso determinado por um Sleeper
+func Contagem(saida io.Writer, sleeper Sleeper) {
+	for i := inicioContagem; i > 0; i-- {
+		sleeper.Pausa()
+		fmt.Fprintln(saida, i)
+	}
+
+	sleeper.Pausa()
+	fmt.Fprint(saida, ultimaPalavra)
+}
+
+func main() {
+	sleeper := &SleeperPadrao{}
+	Contagem(os.Stdout, sleeper)
+}
diff --git a/mocks/v5/contagem_test.go b/mocks/v5/contagem_test.go
new file mode 100644
index 00000000..9cbb3903
--- /dev/null
+++ b/mocks/v5/contagem_test.go
@@ -0,0 +1,82 @@
+package main
+
+import (
+	"bytes"
+	"reflect"
+	"testing"
+	"time"
+)
+
+func TestContagem(t *testing.T) {
+
+	t.Run("imprime 3 até Vai!", func(t *testing.T) {
+		buffer := &bytes.Buffer{}
+		Contagem(buffer, &SpyContagemOperacoes{})
+
+		resultado := buffer.String()
+		esperado := `3
+2
+1
+Vai!`
+
+		if resultado != esperado {
+			t.Errorf("resultado '%s', esperado '%s'", resultado, esperado)
+		}
+	})
+
+	t.Run("pausa antes de cada impressão", func(t *testing.T) {
+		spyImpressoraSleep := &SpyContagemOperacoes{}
+		Contagem(spyImpressoraSleep, spyImpressoraSleep)
+
+		esperado := []string{
+			pausa,
+			escrita,
+			pausa,
+			escrita,
+			pausa,
+			escrita,
+			pausa,
+			escrita,
+		}
+
+		if !reflect.DeepEqual(esperado, spyImpressoraSleep.Chamadas) {
+			t.Errorf("esperado %v chamadas, resultado %v", esperado, spyImpressoraSleep.Chamadas)
+		}
+	})
+}
+
+func TestSleeperConfiguravel(t *testing.T) {
+	tempoPausa := 5 * time.Second
+
+	tempoSpy := &TempoSpy{}
+	sleeper := SleeperConfiguravel{tempoPausa, tempoSpy.Pausa}
+	sleeper.Pausa()
+
+	if tempoSpy.duracaoPausa != tempoPausa {
+		t.Errorf("deveria ter pausado por %v, mas pausou por %v", tempoPausa, tempoSpy.duracaoPausa)
+	}
+}
+
+type SpyContagemOperacoes struct {
+	Chamadas []string
+}
+
+func (s *SpyContagemOperacoes) Pausa() {
+	s.Chamadas = append(s.Chamadas, pausa)
+}
+
+func (s *SpyContagemOperacoes) Write(p []byte) (n int, err error) {
+	s.Chamadas = append(s.Chamadas, escrita)
+	return
+}
+
+const escrita = "escrita"
+const pausa = "pausa"
+
+type TempoSpy struct {
+	duracaoPausa time.Duration
+}
+
+func (t *TempoSpy) Pausa(duracao time.Duration) {
+	t.duracaoPausa = duracao
+}
diff --git a/mocks/v5/main.go b/mocks/v5/main.go
new file mode 100644
index 00000000..0968c60c
--- /dev/null
+++ b/mocks/v5/main.go
@@ -0,0 +1,43 @@
+package main
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"time"
+)
+
+/// Sleeper te permite definir pausas
+type Sleeper interface {
+	Pausa()
+}
+
+// SleeperConfiguravel é uma implementação de Sleepr com uma pausa definida
+type SleeperConfiguravel struct {
+	duracao time.Duration
+	pausa   func(time.Duration)
+}
+
+// Pausa vai pausar a execução pela Duração definida
+func (s *SleeperConfiguravel) Pausa() {
+	s.pausa(s.duracao)
+}
+
+const ultimaPalavra = "Vai!"
+const inicioContagem = 3
+
+// Contagem imprime uma contagem de 3 para a saída com um atraso determinado por um Sleeper
+func Contagem(saida io.Writer, sleeper Sleeper) {
+	for i := inicioContagem; i > 0; i-- {
+		sleeper.Pausa()
+		fmt.Fprintln(saida, i)
+	}
+
+	sleeper.Pausa()
+	fmt.Fprint(saida, ultimaPalavra)
+}
+
+func main() {
+	sleeper := &SleeperConfiguravel{1 * time.Second, time.Sleep}
+	Contagem(os.Stdout, sleeper)
+}
diff --git a/primeiros-passos-com-go/mocking.md b/primeiros-passos-com-go/mocking.md
deleted file mode 100644
index 7e0a31bd..00000000
--- a/primeiros-passos-com-go/mocking.md
+++ /dev/null
@@ -1,636 +0,0 @@
-# Mocking
-
-[**You can find all the code for this chapter here**](https://github.com/quii/learn-go-with-tests/tree/master/mocking)
-
-You have been asked to write a program which counts from 3, printing each number on a new line \(with a 1 second pause\) and when it reaches zero it will print "Go!" and exit.
-
-```text
-3
-2
-1
-Go!
-```
-
-We'll tackle this by writing a function called `Countdown` which we will then put inside a `main` program so it looks something like this:
-
-```go
-package main
-
-func main() {
-    Countdown()
-}
-```
-
-While this is a pretty trivial program, to test it fully we will need as always to take an _iterative_, _test-driven_ approach.
-
-What do I mean by iterative? We make sure we take the smallest steps we can to have _useful software_.
-
-We dont want to spend a long time with code that will theoretically work after some hacking because that's often how developers fall down rabbit holes. **It's an important skill to be able to slice up requirements as small as you can so you can have** _**working software**_**.**
-
-Here's how we can divide our work up and iterate on it:
-
-* Print 3
-* Print 3 to Go!
-* Wait a second between each line
-
-## Write the test first
-
-Our software needs to print to stdout and we saw how we could use DI to facilitate testing this in the DI section.
-
-```go
-func TestCountdown(t *testing.T) {
-    buffer := &bytes.Buffer{}
-
-    Countdown(buffer)
-
-    got := buffer.String()
-    want := "3"
-
-    if got != want {
-        t.Errorf("got '%s' want '%s'", got, want)
-    }
-}
-```
-
-If anything like `buffer` is unfamiliar to you, re-read [the previous section](dependency-injection.md).
-
-We know we want our `Countdown` function to write data somewhere and `io.Writer` is the de-facto way of capturing that as an interface in Go.
-
-* In `main` we will send to `os.Stdout` so our users see the countdown printed to the terminal.
-* In test we will send to `bytes.Buffer` so our tests can capture what data is being generated.
-
-## Try and run the test
-
-`./countdown_test.go:11:2: undefined: Countdown`
-
-## Write the minimal amount of code for the test to run and check the failing test output
-
-Define `Countdown`
-
-```go
-func Countdown() {}
-```
-
-Try again
-
-```go
-./countdown_test.go:11:11: too many arguments in call to Countdown
-    have (*bytes.Buffer)
-    want ()
-```
-
-The compiler is telling you what your function signature could be, so update it.
-
-```go
-func Countdown(out *bytes.Buffer) {}
-```
-
-`countdown_test.go:17: got '' want '3'`
-
-Perfect!
-
-## Write enough code to make it pass
-
-```go
-func Countdown(out *bytes.Buffer) {
-    fmt.Fprint(out, "3")
-}
-```
-
-We're using `fmt.Fprint` which takes an `io.Writer` \(like `*bytes.Buffer`\) and sends a `string` to it. The test should pass.
-
-## Refactor
-
-We know that while `*bytes.Buffer` works, it would be better to use a general purpose interface instead.
-
-```go
-func Countdown(out io.Writer) {
-    fmt.Fprint(out, "3")
-}
-```
-
-Re-run the tests and they should be passing.
-
-To complete matters, let's now wire up our function into a `main` so we have some working software to reassure ourselves we're making progress.
-
-```go
-package main
-
-import (
-    "fmt"
-    "io"
-    "os"
-)
-
-func Countdown(out io.Writer) {
-    fmt.Fprint(out, "3")
-}
-
-func main() {
-    Countdown(os.Stdout)
-}
-```
-
-Try and run the program and be amazed at your handywork.
-
-Yes this seems trivial but this approach is what I would recommend for any project. **Take a thin slice of functionality and make it work end-to-end, backed by tests.**
-
-Next we can make it print 2,1 and then "Go!".
-
-## Write the test first
-
-By investing in getting the overall plumbing working right, we can iterate on our solution safely and easily. We will no longer need to stop and re-run the program to be confident of it working as all the logic is tested.
-
-```go
-func TestCountdown(t *testing.T) {
-    buffer := &bytes.Buffer{}
-
-    Countdown(buffer)
-
-    got := buffer.String()
-    want := `3
-2
-1
-Go!`
-
-    if got != want {
-        t.Errorf("got '%s' want '%s'", got, want)
-    }
-}
-```
-
-The backtick syntax is another way of creating a `string` but lets you put things like newlines which is perfect for our test.
-
-## Try and run the test
-
-```text
-countdown_test.go:21: got '3' want '3
-        2
-        1
-        Go!'
-```
-
-## Write enough code to make it pass
-
-```go
-func Countdown(out io.Writer) {
-    for i := 3; i > 0; i-- {
-        fmt.Fprintln(out, i)
-    }
-    fmt.Fprint(out, "Go!")
-}
-```
-
-Use a `for` loop counting backwards with `i--` and use `fmt.Fprintln` to print to `out` with our number followed by a newline character. Finally use `fmt.Fprint` to send "Go!" aftward.
-
-## Refactor
-
-There's not much to refactor other than refactoring some magic values into named constants.
-
-```go
-const finalWord = "Go!"
-const countdownStart = 3
-
-func Countdown(out io.Writer) {
-    for i := countdownStart; i > 0; i-- {
-        fmt.Fprintln(out, i)
-    }
-    fmt.Fprint(out, finalWord)
-}
-```
-
-If you run the program now, you should get the desired output but we don't have it as a dramatic countdown with the 1 second pauses.
-
-Go let's you achieve this with `time.Sleep`. Try adding it in to our code.
-
-```go
-func Countdown(out io.Writer) {
-    for i := countdownStart; i > 0; i-- {
-        time.Sleep(1 * time.Second)
-        fmt.Fprintln(out, i)
-    }
-
-    time.Sleep(1 * time.Second)
-    fmt.Fprint(out, finalWord)
-}
-```
-
-If you run the program it works as we want it to.
-
-## Mocking
-
-The tests still pass and the software works as intended but we have some problems:
-
-* Our tests take 4 seconds to run.
-  * Every forward thinking post about software development emphasises the importance of quick feedback loops.
-  * **Slow tests ruin developer productivity**.
-  * Imagine if the requirements get more sophisticated warranting more tests. Are we happy with 4s added to the test run for every new test of `Countdown`?
-* We have not tested an important property of our function.
-
-We have a dependency on `Sleep`ing which we need to extract so we can then control it in our tests.
-
-If we can _mock_ `time.Sleep` we can use _dependency injection_ to use it instead of a "real" `time.Sleep` and then we can **spy on the calls** to make assertions on them.
-
-## Write the test first
-
-Let's define our dependency as an interface. This lets us then use a _real_ Sleeper in `main` and a _spy sleeper_ in our tests. By using an interface our `Countdown` function is oblivious to this and adds some flexibility for the caller.
-
-```go
-type Sleeper interface {
-    Sleep()
-}
-```
-
-I made a design decision that our `Countdown` function would not be responsible for how long the sleep is. This simplifies our code a little for now at least and means a user of our function can configure that sleepiness however they like.
-
-Now we need to make a _mock_ of it for our tests to use.
-
-```go
-type SpySleeper struct {
-    Calls int
-}
-
-func (s *SpySleeper) Sleep() {
-    s.Calls++
-}
-```
-
-_Spies_ are a kind of _mock_ which can record how a dependency is used. They can record the arguments sent in, how many times, etc. In our case, we're keeping track of how many times `Sleep()` is called so we can check it in our test.
-
-Update the tests to inject a dependency on our Spy and assert that the sleep has been called 4 times.
-
-```go
-func TestCountdown(t *testing.T) {
-    buffer := &bytes.Buffer{}
-    spySleeper := &SpySleeper{}
-
-    Countdown(buffer, spySleeper)
-
-    got := buffer.String()
-    want := `3
-2
-1
-Go!`
-
-    if got != want {
-        t.Errorf("got '%s' want '%s'", got, want)
-    }
-
-    if spySleeper.Calls != 4 {
-        t.Errorf("not enough calls to sleeper, want 4 got %d", spySleeper.Calls)
-    }
-}
-```
-
-## Try and run the test
-
-```text
-too many arguments in call to Countdown
-    have (*bytes.Buffer, *SpySleeper)
-    want (io.Writer)
-```
-
-## Write the minimal amount of code for the test to run and check the failing test output
-
-We need to update `Countdown` to accept our `Sleeper`
-
-```go
-func Countdown(out io.Writer, sleeper Sleeper) {
-    for i := countdownStart; i > 0; i-- {
-        time.Sleep(1 * time.Second)
-        fmt.Fprintln(out, i)
-    }
-
-    time.Sleep(1 * time.Second)
-    fmt.Fprint(out, finalWord)
-}
-```
-
-If you try again, your `main` will no longer compile for the same reason
-
-```text
-./main.go:26:11: not enough arguments in call to Countdown
-    have (*os.File)
-    want (io.Writer, Sleeper)
-```
-
-Let's create a _real_ sleeper which implements the interface we need
-
-```go
-type DefaultSleeper struct {}
-
-func (d *DefaultSleeper) Sleep() {
-    time.Sleep(1 * time.Second)
-}
-```
-
-We can then use it in our real application like so
-
-```go
-func main() {
-    sleeper := &DefaultSleeper{}
-    Countdown(os.Stdout, sleeper)
-}
-```
-
-## Write enough code to make it pass
-
-The test is now compiling but not passing because we're still calling the `time.Sleep` rather than the injected in dependency. Let's fix that.
-
-```go
-func Countdown(out io.Writer, sleeper Sleeper) {
-    for i := countdownStart; i > 0; i-- {
-        sleeper.Sleep()
-        fmt.Fprintln(out, i)
-    }
-
-    sleeper.Sleep()
-    fmt.Fprint(out, finalWord)
-}
-```
-
-The test should pass and no longer taking 4 seconds.
-
-### Still some problems
-
-There's still another important property we haven't tested.
-
-`Countdown` should sleep before each print, e.g:
-
-* `Sleep`
-* `Print N`
-* `Sleep`
-* `Print N-1`
-* `Sleep`
-* `Print Go!`
-* etc
-
-Our latest change only asserts that it has slept 4 times, but those sleeps could occur out of sequence.
-
-When writing tests if you're not confident that your tests are giving you sufficient confidence, just break it! \(make sure you have committed your changes to source control first though\). Change the code to the following
-
-```go
-func Countdown(out io.Writer, sleeper Sleeper) {
-    for i := countdownStart; i > 0; i-- {
-        sleeper.Sleep()
-    }
-
-    for i := countdownStart; i > 0; i-- {
-        fmt.Fprintln(out, i)
-    }
-
-    sleeper.Sleep()
-    fmt.Fprint(out, finalWord)
-}
-```
-
-If you run your tests they should still be passing even though the implementation is wrong.
-
-Let's use spying again with a new test to check the order of operations is correct.
-
-We have two different dependencies and we want to record all of their operations into one list. So we'll create _one spy for them both_.
-
-```go
-type CountdownOperationsSpy struct {
-    Calls []string
-}
-
-func (s *CountdownOperationsSpy) Sleep() {
-    s.Calls = append(s.Calls, sleep)
-}
-
-func (s *CountdownOperationsSpy) Write(p []byte) (n int, err error) {
-    s.Calls = append(s.Calls, write)
-    return
-}
-
-const write = "write"
-const sleep = "sleep"
-```
-
-Our `CountdownOperationsSpy` implements both `io.Writer` and `Sleeper`, recording every call into one slice. In this test we're only concerned about the order of operations, so just recording them as list of named operations is sufficient.
-
-We can now add a sub-test into our test suite.
-
-```go
-t.Run("sleep before every print", func(t *testing.T) {
-    spySleepPrinter := &CountdownOperationsSpy{}
-    Countdown(spySleepPrinter, spySleepPrinter)
-
-    want := []string{
-        sleep,
-        write,
-        sleep,
-        write,
-        sleep,
-        write,
-        sleep,
-        write,
-    }
-
-    if !reflect.DeepEqual(want, spySleepPrinter.Calls) {
-        t.Errorf("wanted calls %v got %v", want, spySleepPrinter.Calls)
-    }
-})
-```
-
-This test should now fail. Revert it back and the new test should pass.
-
-We now have two tests spying on the `Sleeper` so we can now refactor our test so one is testing what is being printed and the other one is ensuring we're sleeping in between the prints. Finally we can delete our first spy as it's not used anymore.
-
-```go
-func TestCountdown(t *testing.T) {
-
-    t.Run("prints 3 to Go!", func(t *testing.T) {
-        buffer := &bytes.Buffer{}
-        Countdown(buffer, &CountdownOperationsSpy{})
-
-        got := buffer.String()
-        want := `3
-2
-1
-Go!`
-
-        if got != want {
-            t.Errorf("got '%s' want '%s'", got, want)
-        }
-    })
-
-    t.Run("sleep before every print", func(t *testing.T) {
-        spySleepPrinter := &CountdownOperationsSpy{}
-        Countdown(spySleepPrinter, spySleepPrinter)
-
-        want := []string{
-            sleep,
-            write,
-            sleep,
-            write,
-            sleep,
-            write,
-            sleep,
-            write,
-        }
-
-        if !reflect.DeepEqual(want, spySleepPrinter.Calls) {
-            t.Errorf("wanted calls %v got %v", want, spySleepPrinter.Calls)
-        }
-    })
-}
-```
-
-We now have our function and its 2 important properties properly tested.
-
-## Extending Sleeper to be configurable
-
-A nice feature would be for the `Sleeper` to be configurable.
-
-### Write the test first
-
-Let's first create a new type for `ConfigurableSleeper` that accepts what we need for configuration and testing.
-
-```go
-type ConfigurableSleeper struct {
-    duration time.Duration
-    sleep    func(time.Duration)
-}
-```
-
-We are using `duration` to configure the time slept and `sleep` as a way to pass in a sleep function. The signature of `sleep` is the same as for `time.Sleep` allowing us to use `time.Sleep` in our real implementation and a spy in our tests.
-
-```go
-type SpyTime struct {
-    durationSlept time.Duration
-}
-
-func (s *SpyTime) Sleep(duration time.Duration) {
-    s.durationSlept = duration
-}
-```
-
-With our spy in place, we can create a new test for the configurable sleeper.
-
-```go
-func TestConfigurableSleeper(t *testing.T) {
-    sleepTime := 5 * time.Second
-
-    spyTime := &SpyTime{}
-    sleeper := ConfigurableSleeper{sleepTime, spyTime.Sleep}
-    sleeper.Sleep()
-
-    if spyTime.durationSlept != sleepTime {
-        t.Errorf("should have slept for %v but slept for %v", sleepTime, spyTime.durationSlept)
-    }
-}
-```
-
-There should be nothing new in this test and it is setup very similar to the previous mock tests.
-
-### Try and run the test
-
-```text
-sleeper.Sleep undefined (type ConfigurableSleeper has no field or method Sleep, but does have sleep)
-```
-
-You should see a very clear error message indicating that we do not have a `Sleep` method created on our `ConfigurableSleeper`.
-
-### Write the minimal amount of code for the test to run and check failing test output
-
-```go
-func (c *ConfigurableSleeper) Sleep() {
-}
-```
-
-With our new `Sleep` function implemented we have a failing test.
-
-```text
-countdown_test.go:56: should have slept for 5s but slept for 0s
-```
-
-### Write enough code to make it pass
-
-All we need to do now is implement the `Sleep` function for `ConfigurableSleeper`.
-
-```go
-func (c *ConfigurableSleeper) Sleep() {
-    c.sleep(c.duration)
-}
-```
-
-With this change all of the test should be passing again.
-
-### Cleanup and refactor
-
-The last thing we need to do is to actually use our `ConfigurableSleeper` in the main function.
-
-```go
-func main() {
-    sleeper := &ConfigurableSleeper{1 * time.Second, time.Sleep}
-    Countdown(os.Stdout, sleeper)
-}
-```
-
-If we run the tests and the program manually, we can see that all the behavior remains the same.
-
-Since we are using the `ConfigurableSleeper`, it is safe to delete the `DefaultSleeper` implementation. Wrapping up our program.
-
-## But isn't mocking evil?
-
-You may have heard mocking is evil. Just like anything in software development it can be used for evil, just like [DRY](https://en.wikipedia.org/wiki/Don%27t_repeat_yourself).
-
-People normally get in to a bad state when they don't _listen to their tests_ and are _not respecting the refactoring stage_.
-
-If your mocking code is becoming complicated or you are having to mock out lots of things to test something, you should _listen_ to that bad feeling and think about your code. Usually it is a sign of
-
-* The thing you are testing is having to do too many things
-  * Break the module apart so it does less
-* Its dependencies are too fine-grained
-  * Think about how you can consolidate some of these dependencies into one meaningful module
-* Your test is too concerned with implementation details
-  * Favour testing expected behaviour rather than the implementation
-
-Normally a lot of mocking points to _bad abstraction_ in your code.
-
-**What people see here is a weakness in TDD but it is actually a strength**, more often than not poor test code is a result of bad design or put more nicely, well-designed code is easy to test.
-
-### But mocks and tests are still making my life hard!
-
-Ever run into this situation?
-
-* You want to do some refactoring
-* To do this you end up changing lots of tests
-* You question TDD and make a post on Medium titled "Mocking considered harmful"
-
-This is usually a sign of you testing too much _implementation detail_. Try to make it so your tests are testing _useful behaviour_ unless the implementation is really important to how the system runs.
-
-It is sometimes hard to know _what level_ to test exactly but here are some thought processes and rules I try to follow:
-
-* **The definition of refactoring is that the code changes but the behaviour stays the same**. If you have decided to do some refactoring in theory you should be able to do make the commit without any test changes. So when writing a test ask yourself
-  * Am i testing the behaviour I want or the implementation details?
-  * If i were to refactor this code, would I have to make lots of changes to the tests?
-* Although Go lets you test private functions, I would avoid it as private functions are to do with implementation.
-* I feel like if a test is working with **more than 3 mocks then it is a red flag** - time for a rethink on the design
-* Use spies with caution. Spies let you see the insides of the algorithm you are writing which can be very useful but that means a tighter coupling between your test code and the implementation. **Be sure you actually care about these details if you're going to spy on them**
-
-As always, rules in software development aren't really rules and there can be exceptions. [Uncle Bob's article of "When to mock"](https://8thlight.com/blog/uncle-bob/2014/05/10/WhenToMock.html) has some excellent pointers.
-
-## Wrapping up
-
-### More on TDD approach
-
-* When faced with less trivial examples, break the problem down into "thin vertical slices". Try to get to a point where you have _working software backed by tests_ as soon as you can, to avoid getting in rabbit holes and taking a "big bang" approach.
-* Once you have some working software it should be easier to _iterate with small steps_ until you arrive at the software you need.
-
-> "When to use iterative development? You should use iterative development only on projects that you want to succeed."
-
-Martin Fowler.
-
-### Mocking
-
-* **Without mocking important areas of your code will be untested**. In our case we would not be able to test that our code paused between each print but there are countless other examples. Calling a service that _can_ fail? Wanting to test your system in a particular state? It is very hard to test these scenarios without mocking.
-* Without mocks you may have to set up databases and other third parties things just to test simple business rules. You're likely to have slow tests, resulting in **slow feedback loops**.
-* By having to spin up a database or a webservice to test something you're likely to have **fragile tests** due to the unreliability of such services.
-
-Once a developer learns about mocking it becomes very easy to over-test every single facet of a system in terms of the _way it works_ rather than _what it does_. Always be mindful about **the value of your tests** and what impact they would have in future refactoring.
-
-In this post about mocking we have only covered **Spies** which are a kind of mock. There are different kind of mocks. [Uncle Bob explains the types in a very easy to read article](https://8thlight.com/blog/uncle-bob/2014/05/14/TheLittleMocker.html). In later chapters we will need to write code that depends on others for data, which is where we will show **Stubs** in action.
-
diff --git a/primeiros-passos-com-go/mocks.md b/primeiros-passos-com-go/mocks.md
new file mode 100644
index 00000000..d300e9dc
--- /dev/null
+++ b/primeiros-passos-com-go/mocks.md
@@ -0,0 +1,640 @@
+# Mocking
+
+[**Você pode encontrar todos os códigos para esse capítulo aqui**](https://github.com/larien/learn-go-with-tests/tree/master/mocks)
+
+Te pediram para criar um programa que conta a partir de 3, imprimindo cada número em uma linha nova (com um segundo de intervalo entre cada uma) e quando chega a zero, imprime "Vai!" e sai.
+
+```text
+3
+2
+1
+Vai!
+```
+
+Vamos resolver isso escrevendo uma função chamada `Contagem` que vamos colocar dentro de um programa `main` e se parecer com algo assim:
+
+```go
+package main
+
+func main() {
+    Contagem()
+}
+```
+
+Apesar de ser um programa simples, para testá-lo completamente vamos precisar, como de costume, de uma abordagem _iterativa_ e _orientada a testes_.
+
+Mas o que quero dizer com iterativa? Precisamos ter certeza de que tomamos os menores passos que pudermos para ter um _software_ útil.
+
+Não queremos passar muito tempo com código que vai funcionar hora ou outra após alguma implementação mirabolante, porque é assim que os desenvolvedores caem em armadilhas. **É importante ser capaz de dividir os requerimentos da menor forma que conseguir para você ter um** _**software funcionando**_**.**
+
+Podemos separar essa tarefa da seguinte forma:
+
+-   Imprimir 3
+-   Imprimir de 3 para Vai!
+-   Esperar um segundo entre cada linha
+
+## Escreva o teste primeiro
+
+Nosso software precisa imprimir para a saída. Vimos como podemos usar a injeção de dependência para facilitar nosso teste na [seção anterior](https://github.com/larien/learn-go-with-tests/tree/master/primeiros-passos-com-go/injecao-de-dependencia.md).
+
+```go
+func TestContagem(t *testing.T) {
+    buffer := &bytes.Buffer{}
+
+    Contagem(buffer)
+
+    resultado := buffer.String()
+    esperado := "3"
+
+    if resultado != esperado {
+        t.Errorf("resultado '%s', esperado '%s'", resultado, esperado)
+    }
+}
+```
+
+Se tiver dúvidas sobre o `buffer`, leia a [seção anterior](https://github.com/larien/learn-go-with-tests/tree/master/primeiros-passos-com-go/injecao-de-dependencia.md) novamente.
+
+Sabemos que nossa função `Contagem` precisa escrever dados em algum lugar e o `io.Writer` é a forma de capturarmos essa saída como uma interface em Go.
+
+-   Na `main`, vamos enviar o `os.Stdout` como parâmetro para nossos usuários verem a contagem regressiva impressa no terminal.
+-   No teste, vamos enviar o `bytes.Buffer` como parâmetro para que nossos testes possam capturar que dado está sendo gerado.
+
+## Execute o teste
+
+`./contagem_test.go:11:2: undefined: Contagem`
+
+`indefinido: Contagem`
+
+## Escreva o mínimo de código possível para fazer o teste rodar e verifique a saída do teste que tiver falhado
+
+Defina `Contagem`:
+
+```go
+func Contagem() {}
+```
+
+Tente novamente:
+
+```go
+./contagem_test.go:11:11: too many arguments in call to Countdown
+    have (*bytes.Buffer)
+    want ()
+```
+
+`argumentos demais na chamada para Contagem`
+
+O compilador está te dizendo como a assinatura da função deve ser, então é só atualizá-la.
+
+```go
+func Contagem(saida *bytes.Buffer) {}
+```
+
+`contagem_test.go:17: resultado '', esperado '3'`
+
+Perfeito!
+
+## Escreva código o suficiente para fazer o teste passar
+
+```go
+func Contagem(saida *bytes.Buffer) {
+    fmt.Fprint(saida, "3")
+}
+```
+
+Estamos usando `fmt.Fprint`, o que significa que ele recebe um `io.Writer` (como `*bytes.Buffer`) e envia uma `string` para ele. O teste deve passar.
+
+## Refatoração
+
+Agora sabemos que, apesar do `*bytes.Buffer` funcionar, seria melhor ter uma interface de propósito geral ao invés disso.
+
+```go
+func Contagem(saida io.Writer) {
+    fmt.Fprint(saida, "3")
+}
+```
+
+Execute os testes novamente e eles devem passar.
+
+Só para finalizar, vamos colocar nossa função dentro da `main` para que possamos executar o software para nos assegurarmos de que estamos progredindo.
+
+```go
+package main
+
+import (
+    "fmt"
+    "io"
+    "os"
+)
+
+func Contagem(saida io.Writer) {
+	fmt.Fprint(saida, "3")
+}
+
+func main() {
+	Contagem(os.Stdout)
+}
+```
+
+Execute o programa e surpreenda-se com seu trabalho.
+
+Apesar de parecer simples, essa é a abordagem que recomendo para qualquer projeto. **Escolher uma pequena parte da funcionalidade e fazê-la funcionar do começo ao fim com apoio de testes.**
+
+Depois, precisamos fazer o software imprimir 2, 1 e então "Vai!".
+
+## Escreva o teste primeiro
+
+Após investirmos tempo e esforço para fazer o principal funcionar, podemos iterar nossa solução com segurança e de forma simples. Não vamos mais precisar parar e executar o programa novamente para ter confiança de que ele está funcionando, desde que a lógica esteja testada.
+
+```go
+func TestContagem(t *testing.T) {
+    buffer := &bytes.Buffer{}
+
+    Contagem(buffer)
+
+    resultado := buffer.String()
+    esperado := `3
+2
+1
+Vai!`
+    if resultado != esperado {
+        t.Errorf("resultado '%s', esperado '%s'", resultado, esperado)
+    }
+}
+```
+
+A sintaxe de aspas simples é outra forma de criar uma `string`, mas te permite colocar coisas como linhas novas, o que é perfeito para nosso teste.
+
+## Execute o teste
+
+```bash
+contagem_test.go:21: resultado '3', esperado '3
+        2
+        1
+        Vai!'
+```
+
+## Escreva código o suficiente para fazer o teste passar
+
+```go
+func Contagem(saida io.Writer) {
+    for i := 3; i > 0; i-- {
+        fmt.Fprintln(saida, i)
+    }
+    fmt.Fprint(saida, "Go!")
+}
+```
+
+Usamos um laço `for` fazendo contagem regressiva com `i--` e depois `fmt.Fprintln` para imprimir a `saida` com nosso número seguro por um caracter de nova linha. Finalmente, usamos o `fmt.Fprint` para enviar "Vai!" no final.
+
+## Refatoração
+
+Não há muito para refatorar além de transformar alguns valores mágicos em constantes com nomes descritivos.
+
+```go
+const ultimaPalavra = "Go!"
+const inicioContagem = 3
+
+func Contagem(saida io.Writer) {
+    for i := inicioContagem; i > 0; i-- {
+        fmt.Fprintln(saida, i)
+    }
+    fmt.Fprint(saida, ultimaPalavra)
+}
+```
+
+Se executar o programa agora, você deve obter a saída desejada, mas não tem uma contagem regressiva dramática com as pausas de 1 segundo.
+
+Go te permite obter isso com `time.Sleep`. Tente adicionar essa função ao seu código.
+
+```go
+func Contagem(saida io.Writer) {
+    for i := inicioContagem; i > 0; i-- {
+        time.Sleep(1 * time.Second)
+        fmt.Fprintln(saida, i)
+    }
+
+    time.Sleep(1 * time.Second)
+    fmt.Fprint(saida, ultimaPalavra)
+}
+```
+
+Se você executar o programa, ele funciona conforme esperado.
+
+## Mock
+
+Os testes ainda vão passar e o software funciona como planejado, mas temos alguns problemas:
+
+-   Nossos testes levam 4 segundos para rodar.
+    -   Todo conteúdo gerado sobre desenvolvimento de software enfatiza a importância de loops de feedback rápidos.
+    -   **Testes lentos arruinam a produtividade do desenvolvedor**.
+    -   Imagine se os requerimentos ficam mais sofisticados, gerando a necessidade de mais testes. É viável adicionar 4s para cada teste novo de `Contagem`?
+-   Não testamos uma propriedade importante da nossa função.
+
+Temos uma dependência no `Sleep` que precisamos extrair para podermos controlá-la nos nossos testes.
+
+Se conseguirmos _mockar_ o `time.Sleep`, podemos usar a _injeção de dependências_ para usá-lo ao invés de um `time.Sleep` "de verdade", e então podemos **verificar as chamadas** para certificar de que estão corretas.
+
+## Escreva o teste primeiro
+
+Vamos definir nossa dependência como uma interface. Isso nos permite usar um Sleeper _de verdade_ em `main` e um _sleeper spy_ nos nossos testes. Usar uma interface na nossa função `Contagem` é essencial para isso e dá certa flexibilidade à função que a chamar.
+
+```go
+type Sleeper interface {
+    Sleep()
+}
+```
+
+Tomei uma decisão de design que nossa função `Contagem` não seria responsável por quanto tempo o sleep leva. Isso simplifica um pouco nosso código, pelo menos por enquanto, e significa que um usuário da nossa função pode configurar a duração desse tempo como preferir.
+
+Agora precisamos criar um _mock_ disso para usarmos nos nossos testes.
+
+```go
+type SleeperSpy struct {
+    Chamadas int
+}
+
+func (s *SleeperSpy) Sleep() {
+    s.Chamadas++
+}
+```
+
+_Spies_ (espiões) são um tipo de _mock_ em que podemos gravar como uma dependência é usada. Eles podem gravar os argumentos definidos, quantas vezes são usados etc. No nosso caso, vamos manter o controle de quantas vezes `Sleep()` é chamada para verificá-la no nosso teste.
+
+Atualize os testes para injetar uma dependência no nosso Espião e verifique se o sleep foi chamado 4 vezes.
+
+```go
+func TestContagem(t *testing.T) {
+    buffer := &bytes.Buffer{}
+    sleeperSpy := &SleeperSpy{}
+
+    Contagem(buffer, sleeperSpy)
+
+    resultado := buffer.String()
+    esperado := `3
+2
+1
+Vai!`
+
+    if resultado != esperado {
+        t.Errorf("resultado '%s', esperado '%s'", resultado, esperado)
+    }
+
+    if sleeperSpy.Chamadas != 4 {
+        t.Errorf("não houve chamadas suficientes do sleeper, esperado 4, resultado %d", sleeperSpy.Chamadas)
+    }
+}
+```
+
+## Execute o teste
+
+```bash
+too many arguments in call to Contagem
+    have (*bytes.Buffer, *SpySleeper)
+    want (io.Writer)
+```
+
+## Escreva o mínimo de código possível para fazer o teste rodar e verifique a saída do teste que tiver falhado
+
+Precisamos atualizar a `Contagem` para aceitar nosso `Sleeper`:
+
+```go
+func Contagem(saida io.Writer, sleeper Sleeper) {
+    for i := inicioContagem; i > 0; i-- {
+        time.Sleep(1 * time.Second)
+        fmt.Fprintln(saida, i)
+    }
+
+    time.Sleep(1 * time.Second)
+    fmt.Fprint(saida, ultimaPalavra)
+}
+```
+
+Se tentar novamente, nossa `main` não vai mais compilar pelo mesmo motivo:
+
+```text
+./main.go:26:11: not enough arguments in call to Contagem
+    have (*os.File)
+    want (io.Writer, Sleeper)
+```
+
+Vamos criar um sleeper _de verdade_ que implementa a interface que precisamos:
+
+```go
+type SleeperPadrao struct {}
+
+func (d *SleeperPadrao) Sleep() {
+	time.Sleep(1 * time.Second)
+}
+```
+
+Podemos usá-lo na nossa aplicação real, como:
+
+```go
+func main() {
+    sleeper := &SleeperPadrao{}
+    Contagem(os.Stdout, sleeper)
+}
+```
+
+## Escreva código o suficiente para fazer o teste passar
+
+Agora o teste está compilando, mas não passando. Isso acontece porque ainda estamos chamando o `time.Sleep` ao invés da injetada. Vamos arrumar isso.
+
+```go
+func Contagem(saida io.Writer, sleeper Sleeper) {
+    for i := inicioContagem; i > 0; i-- {
+        sleeper.Sleep()
+        fmt.Fprintln(saida, i)
+    }
+
+    sleeper.Sleep()
+    fmt.Fprint(saida, ultimaPalavra)
+}
+```
+
+O teste deve passar sem levar 4 segundos.
+
+### Ainda temos alguns problemas
+
+Ainda há outra propriedade importante que não estamos testando.
+
+A `Contagem` deve ter uma pausa para cada impressão, como por exemplo:
+
+-   `Pausa`
+-   `Imprime N`
+-   `Pausa`
+-   `Imprime N-1`
+-   `Pausa`
+-   `Imprime Vai!`
+-   etc
+
+Nossa alteração mais recente só verifica se o software teve 4 pausas, mas essas pausas poderiam ocorrer fora de ordem.
+
+Quando escrevemos testes, se não estiver confiante de que seus testes estão te dando confiança o suficiente, quebre-o (mas certifique-se de que você salvou suas alterações antes)! Mude o código para o seguinte:
+
+```go
+func Contagem(saida io.Writer, sleeper Sleeper) {
+    for i := inicioContagem; i > 0; i-- {
+        sleeper.Pausa()
+        fmt.Fprintln(saida, i)
+    }
+
+    for i := inicioContagem; i > 0; i-- {
+        fmt.Fprintln(saida, i)
+    }
+
+    sleeper.Pausa()
+    fmt.Fprint(saida, ultimaPalavra)
+}
+```
+
+Se executar seus testes, eles ainda vão passar, apesar da implementação estar errada.
+
+Vamos usar o spy novamente com um novo teste para verificar se a ordem das operações está correta.
+
+Temos duas dependências diferentes e queremos gravar todas as operações delas em uma lista. Logo, vamos criar _um spy para ambas_.
+
+```go
+type SpyContagemOperacoes struct {
+    Chamadas []string
+}
+
+func (s *SpyContagemOperacoes) Pausa() {
+    s.Chamadas = append(s.Chamadas, pausa)
+}
+
+func (s *SpyContagemOperacoes) Write(p []byte) (n int, err error) {
+    s.Chamadas = append(s.Chamadas, escrita)
+    return
+}
+
+const escrita = "escrita"
+const pausa = "pausa"
+```
+
+Nosso `SpyContagemOperacoes` implementa tanto o `io.Writer` quanto o `Sleeper`, gravando cada chamada em um slice. Nesse teste, temos preocupação apenas na ordem das operações, então apenas gravá-las em uma lista de operações nomeadas é suficiente.
+
+Agora podemos adicionar um subteste no nosso conjunto de testes.
+
+```go
+t.Run("pausa antes de cada impressão", func(t *testing.T) {
+        spyImpressoraSleep := &SpyContagemOperacoes{}
+        Contagem(spyImpressoraSleep, spyImpressoraSleep)
+
+        esperado := []string{
+            pausa,
+            escrita,
+            pausa,
+            escrita,
+            pausa,
+            escrita,
+            pausa,
+            escrita,
+        }
+
+        if !reflect.DeepEqual(esperado, spyImpressoraSleep.Chamadas) {
+            t.Errorf("esperado %v chamadas, resultado %v", esperado, spyImpressoraSleep.Chamadas)
+        }
+    })
+```
+
+Esse teste deve falhar. Volte o código que quebramos para a versão correta e agora o novo teste deve passar.
+
+Agora temos dois spies no `Sleeper`. O próximo passo é refatorar nosso teste para que um teste o que está sendo impresso e o outro se certifique de que estamos pausando entre as impressões. Por fim, podemos apagar nosso primeiro spy, já que não é mais utilizado.
+
+```go
+func TestContagem(t *testing.T) {
+
+    t.Run("imprime 3 até Vai!", func(t *testing.T) {
+        buffer := &bytes.Buffer{}
+        Contagem(buffer, &SpyContagemOperacoes{})
+
+        resultado := buffer.String()
+        esperado := `3
+2
+1
+Vai!`
+
+        if resultado != esperado {
+            t.Errorf("resultado '%s', esperado '%s'", resultado, esperado)
+        }
+    })
+
+    t.Run("pausa antes de cada impressão", func(t *testing.T) {
+        spyImpressoraSleep := &SpyContagemOperacoes{}
+        Contagem(spyImpressoraSleep, spyImpressoraSleep)
+
+        esperado := []string{
+            pausa,
+            escrita,
+            pausa,
+            escrita,
+            pausa,
+            escrita,
+            pausa,
+            escrita,
+        }
+
+        if !reflect.DeepEqual(esperado, spyImpressoraSleep.Chamadas) {
+            t.Errorf("esperado %v chamadas, resultado %v", esperado, spyImpressoraSleep.Chamadas)
+        }
+    })
+}
+```
+
+Agora temos nossa função e suas duas propriedades testadas adequadamente.
+
+## Extendendo o Sleeper para se tornar configurável
+
+Uma funcionalidade legal seria o `Sleeper` ser configurável.
+
+### Escreva o teste primeiro
+
+Agora vamos criar um novo tipo para `SleeperConfiguravel` que aceita o que precisamos para configuração e teste.
+
+```go
+type SleeperConfiguravel struct {
+	duracao time.Duration
+	pausa   func(time.Duration)
+}
+```
+
+Estamos usando a `duracao` para configurar o tempo de pausa e `pausa` como forma de passar uma função de pausa. A assinatura de `sleep` é a mesma de `time.Sleep`, nos permitindo usar `time.Sleep` na nossa implementação real e um spy nos nossos testes.
+
+```go
+type TempoSpy struct {
+	duracaoPausa time.Duration
+}
+
+func (t *TempoSpy) Pausa(duracao time.Duration) {
+	t.duracaoPausa = duracao
+}
+```
+
+Definindo nosso spy, podemos criar um novo teste para o sleeper configurável.
+
+```go
+func TestSleeperConfiguravel(t *testing.T) {
+    tempoPausa := 5 * time.Second
+
+    tempoSpy := &TempoSpy{}
+    sleeper := SleeperConfiguravel{tempoPausa, tempoSpy.Pausa}
+    sleeper.Pausa()
+
+    if tempoSpy.duracaoPausa != tempoPausa {
+        t.Errorf("deveria ter pausado por %v, mas pausou por %v", tempoPausa, tempoSpy.duracaoPausa)
+    }
+}
+```
+
+Não há nada de novo nesse teste e seu funcionamento é bem semelhante aos testes com mock anteriores.
+
+### Execute o teste
+
+```bash
+sleeper.Pausa undefined (type SleeperConfiguravel has no field or method Pausa, but does have pausa)
+```
+
+`sleeper.Pausa não definido (tipo SleeperConfiguravel não tem campo ou método Pausa, mas tem o método sleep`
+
+Você deve ver uma mensagem de erro bem clara indicando que não temos um método `Pausa` criado no nosso `SleeperConfiguravel`.
+
+### Escreva o mínimo de código possível para fazer o teste rodar e verifique a saída do teste que tiver falhado
+
+```go
+func (c *SleeperConfiguravel) Pausa() {
+}
+```
+
+Com nossa nova função `Pausa` implementada, ainda há um teste falhando.
+
+```bash
+contagem_test.go:56: deveria ter pausado por 5s, mas pausou por 0s
+```
+
+### Escreva código o suficiente para fazer o teste passar
+
+Tudo o que precisamos fazer agora é implementar a função `Pausa` para o `SleeperConfiguravel`.
+
+```go
+func (s *SleeperConfiguravel) Pausa() {
+    s.pausa(s.duracao)
+}
+```
+
+Com essa mudança, todos os testes devem voltar a passar.
+
+### Limpeza e refatoração
+
+A última coisa que precisamos fazer é de fato usar nosso `SleeperConfiguravel` na função main.
+
+```go
+func main() {
+    sleeper := &SleeperConfiguravel{1 * time.Second, time.Sleep}
+    Contagem(os.Stdout, sleeper)
+}
+```
+
+Se executarmos os testes e o programa manualmente, podemos ver que todo o comportamento permanece o mesmo.
+
+Já que estamos usando o `SleeperConfiguravel`, é seguro deletar o `SleeperPadrao`.
+
+## Mas o mock não é do demonho?
+
+Você já deve ter ouvido que o mock é do mal. Quase qualquer coisa no desenvolvimento de software pode ser usada para o mal, assim como o [DRY](https://pt.wikipedia.org/wiki/Don%27t_repeat_yourself).
+
+As pessoas acabam chegando numa fase ruim em que não _dão atenção aos próprios testes_ e _não respeitam a etapa de refatoração_.
+
+Se seu código de mock estiver ficando complicado ou você tem que mockar muita coisa para testar algo, você deve _prestar mais atenção_ a essa sensação ruim e pensar sobre o seu código. Geralmente isso é sinal de que:
+
+-   A coisa que você está testando está tendo que fazer coisas demais
+    -   Modularize a função para que faça menos coisas
+-   Suas dependências estão muito desacopladas
+    -   Pense e uma forma de consolidar algumas das dependências em um módulo útil
+-   Você está se preocupando demais com detalhes de implementação
+    -   Dê prioridade em testar o comportamento esperado ao invés da implementação
+
+Normalmente, muitos pontos de mock são sinais de _abstração ruim_ no seu código.
+
+**As pessoas costumam pensar que essa é uma fraqueza no TDD, mas na verdade é um ponto forte**. Testes mal desenvolvidos são resultado de código ruim. Código bem desenvolvido é fácil de ser testado.
+
+### Só que mocks e testes ainda estão dificultando minha vida!
+
+Já se deparou com a situação a seguir?
+
+-   Você quer refatorar algo
+-   Para isso, você precisa mudar vários testes
+-   Você duvida do TDD e cria um post no Medium chamado "Mock é prejudicial"
+
+Isso costuma ser um sinal de que você está testando muito _detalhe de implementação_. Tente fazer de forma que esteja testando _comportamentos úteis_, a não ser que a implementação seja tão importante que a falta dela possa fazer o sistema quebrar.
+
+Às vezes é difícil saber _qual nível_ testar exatamente, então aqui vai algumas ideias e regras que tento seguir:
+
+-**A definição de refatoração é que o código muda, mas o comportamento permanece o mesmo**. Se você decidiu refatorar alguma coisa, na teoria você deve ser capaz de salvar seu código sem que o teste mude. Então, quando estiver escrevendo um teste, pergunte para si: - Estou testando o comportamento que quero ou detalhes de implementação? - Se fosse refatorar esse código, eu teria que fazer muitas mudanças no meu teste?
+
+-   Apesar do Go te deixar testar funções privadas, eu evitaria fazer isso, já que funções privadas costumam ser detalhes de implementação.
+-   Se o teste estiver com **3 mocks, esse é um sinal de alerta** - hora de repensar no design.
+-   Use spies com cuidado. Spies te deixam ver a parte interna do algoritmo que você está escrevendo, o que pode ser bem útil, mas significa que há um acoplamento maior entre o código do teste e a implementação. **Certifique-se de que você realmente precisa desses detalhes se você vai colocar um spy neles**.
+
+Como sempre, regras no desenvolvimento de software não são realmente regras e podem haver exceções. [O artigo do Uncle Bob sobre "Quando mockar"](https://8thlight.com/blog/uncle-bob/2014/05/10/WhenToMock.html) (em inglês) tem alguns pontos excelentes.
+
+## Resumo
+
+### Mais sobre abordagem TDD
+
+-   Quando se deparar com exemplos menos comuns, divida o problema em "linhas verticais finas". Tente chegar em um ponto onde você tem _software em funcionamento com o apoio de testes_ o mais rápido possível, para evitar cair em armadilhas e se perder.
+-   Quando tiver uma parte do software em funcionamento, deve ser mais fácil _iterar com etapas pequenas_ até chegar no software que você precisa.
+
+> "Quando usar o desenvolvimento iterativo? Apenas em projetos que você quer obter sucesso."
+
+Martin Fowler.
+
+### Mock
+
+-   **Sem o mock, partes importantes do seu código não serão testadas**. No nosso caso, não seríamos capazes de testar se nosso código pausava em cada impressão, mas existem inúmeros exemplos. Chamar um serviço que _pode_ falhar? Querer testar seu sistema em um estado em particular? É bem difícil testar esses casos sem mock.
+-   Sem mocks você pode ter que definir bancos de dados e outras dependências externas só para testar regras de negócio simples. Seus testes provavelmente ficarão mais lentos, resultando em **loops de feedback lentos**.
+-   Ter que se conectar a um banco de dados ou webservice para testar algo vai tornar seus testes **frágeis** por causa da falta de segurança nesses serviços.
+
+Uma vez que a pessoa aprende a mockar, é bem fácil testar pontos demais de um sistema em termos da _forma que ele funciona_ ao invés _do que ele faz_. Sempre tenha em mente o **valor dos seus testes** e qual impacto eles teriam em uma refatoração futura.
+
+Nesse artigo sobre mock, falamos sobre **spies**, que são um tipo de mock. Aqui estão diferentes tipos de mocks. [O Uncle Bob explica os tipos em um artigo bem fácil de ler](https://8thlight.com/blog/uncle-bob/2014/05/14/TheLittleMocker.html) (em inglês). Nos próximos capítulos, vamos precisar escrever código que depende de outros para obter dados, que é aonde vou mostrar os **Stubs** em ação.