This is the 5th post taken from a WIP project called Learn Go by writing Tests the aim of which is to get a familiarity with Go and learn techniques around TDD
- The first post got you up to speed with TDD
- The second post discusses arrays and slices
- The third post teaches structs, methods, interfaces & table driven tests
- The fourth post shows how to do errors and why pointers are useful
Dependency injection
It is assumed that you have read the structs section before as some understanding of interfaces will be needed for this.
There is a lot of misunderstandings around dependency injection around the programming community. Hopefully this guide will show you how
- You dont need a framework
- It does not overcomplicate your design
- It facilitates testing
- It allows you to write great, general-purpose functions.
We want to write a function that greets someone, just like we did in the hello-world chapter but this time we are going to be testing the actual printing.
Just to recap, here is what that function could look like
func Greet(name string) {
fmt.Printf("Hello, %s", name)
}
But how can we test this? Calling fmt.Printf
prints to stdout, which is pretty hard for us to capture using the testing framework.
What we need to do is to be able to inject (which is just a fancy word for pass in) the dependency of printing.
Our function doesn't need to care where or how the printing happens, so we should accept an interface rather than a concrete type.
If we do that, we can then change the implementation to print to something we control so that we can test it. In "real life" you would inject in something that writes to stdout.
If you look at the source code of fmt.Printf
you can see a way for us to hook in
// It returns the number of bytes written and any write error encountered.
func Printf(format string, a ...interface{}) (n int, err error) {
return Fprintf(os.Stdout, format, a...)
}
Interesting! Under the hood Printf
just calls Fprintf
passing in os.Stdout
.
What exactly is an os.Stdout
? What does Fprintf
expect to get passed to it for the 1st argument?
func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) {
p := newPrinter()
p.doPrintf(format, a)
n, err = w.Write(p.buf)
p.free()
return
}
An io.Writer
type Writer interface {
Write(p []byte) (n int, err error)
}
As you write more Go code you will find this interface popping up a lot because it's a great general purpose interface for "put this data somewhere".
So we know under the covers we're ultimately using Writer
to send our greeting somewhere. Let's use this existing abstraction to make our code testable and more reusable.
Write the test first
func TestGreet(t *testing.T) {
buffer := bytes.Buffer{}
Greet(&buffer,"Chris")
got := buffer.String()
want := "Hello, Chris"
if got != want {
t.Errorf("got '%s' want '%s'", got, want)
}
}
The buffer
type from the bytes
package implements the Writer
interface.
So we'll use it in our test to send in as our Writer
and then we can check what was written to it after we invoke Greet
Try and run the test
The test will not compile
./di_test.go:10:7: too many arguments in call to Greet
have (*bytes.Buffer, string)
want (string)
Write the minimal amount of code for the test to run and check the failing test output
Listen to the compiler and fix the problem.
func Greet(writer *bytes.Buffer, name string) {
fmt.Printf("Hello, %s", name)
}
Hello, Chris di_test.go:16: got '' want 'Hello, Chris'
The test fails. Notice that the name is getting printed out, but it's going to stdout.
Write enough code to make it pass
Use the writer to send the greeting to the buffer in our test. Remember fmt.Fprintf
is like fmt.Printf
but instead takes a Writer
to send the string to, whereas fmt.Printf
defaults to stdout.
func Greet(writer *bytes.Buffer, name string) {
fmt.Fprintf(writer, "Hello, %s", name)
}
The test now passes
Refactor
Earlier the compiler told us to pass in a pointer to a bytes.Buffer
. This is technically correct but not very useful.
To demonstrate this, try wiring up the Greet
function into a Go application where we want it to print to stdout.
func main() {
Greet(os.Stdout, "Elodie")
}
./di.go:14:7: cannot use os.Stdout (type *os.File) as type *bytes.Buffer in argument to Greet
As discussed earlier fmt.Fprintf
allows you to pass in an io.Writer
which we know both os.Stdout
and bytes.Buffer
implement.
If we change our code to use the more general purpose interface we can now use it in both tests and in our application.
package main
import (
"fmt"
"os"
"io"
)
func Greet(writer io.Writer, name string) {
fmt.Fprintf(writer, "Hello, %s", name)
}
func main() {
Greet(os.Stdout, "Elodie")
}
More on io.Writer
What other places can we write data to using io.Writer
? Just how general purpose is our Greet
function?
The internet
Run the following
package main
import (
"fmt"
"io"
"net/http"
)
func Greet(writer io.Writer, name string) {
fmt.Fprintf(writer, "Hello, %s", name)
}
func MyGreeterHandler(w http.ResponseWriter, r *http.Request) {
Greet(w, "world")
}
func main() {
http.ListenAndServe(":5000", http.HandlerFunc(MyGreeterHandler))
}
Go to http://localhost:5000. You'll see your greeting function being used.
HTTP servers will be covered in a later chapter so dont worry too much about the details.
When you write a HTTP handler, you are given a http.ResponseWriter
and the http.Request
that was used to make the request. When you implement your server you write your response using the writer.
You can probably guess that http.ResponseWriter
also implements io.Writer
so this is why we could re-use our Greet
function inside our handler.
Wrapping up
Our first round of code was not easy to test because it wrote data to somewhere we couldn't control.
Motivated by our tests we refactored the code so we could control where the data was written by injecting a dependency which allowed us to:
- Test our code If you cant test a function easily, it's usually because of dependencies hard-wired into a function or global state. If you have a global database connection pool for instance that is used by some kind of service layer, it is likely going to be difficult to test and they will be slow to run. DI will motivate you to inject in a database dependency (via an interface) which you can then mock out with something you can control in your tests.
- Separate our concerns, decoupling where the data goes from how to generate it. If you ever feel like a method/function has too many responsibilities (generating data and writing to a db? handling HTTP requests and doing domain level logic?) DI is probably going to be the tool you need.
- Allow our code to be re-used in different contexts The first "new" context our code can be used in is inside tests. But further on if someone wants to try something new with your function they can inject their own dependencies.
What about mocking? I hear you need that for DI and also it's evil
Mocking will be covered in detail later (and it's not evil). You use mocking to replace real things you inject with a pretend version that you can control and inspect in your tests. In our case though, the standard library had something ready for us to use.
The Go standard library is really good, take time to study it
By having some familiarity of the io.Writer
interface we are able to use bytes.Buffer
in our test as our Writer
and then we can use other Writer
s from the standard library to use our function in a command line app or in web server.
The more familiar you are with the standard library the more you'll see these general purpose interfaces which you can then re-use in your own code to make your software reusable in a number of contexts.
This example is heavily influenced from a chapter in The Go Programming language, so if you enjoyed this, go buy it!
Top comments (2)
I see a lot of posts about hello world unit testing in Go but nothing really serious.
I've been learning Go for 2 months now, and I must admit that it's pretty straightforward, but I'm still struggling with "real" unit tests. To my opinion, a unit test MUST only test the output of a given function, and not its dependencies. That means you have to mock things. And that's here that it gets very complicated in Go. I'm a big fan of DI for the testability and the modularity of the code, but how to deal with a dependency that doesn't offer any interface ? Then you write your own interface to wrap your dependency. And then you realize that you need to create a second interface. And a third. And... You got me.
I'm using gin-gonic & uber-zap which are quite easy to mock. It's getting more complicated with jwt-go. And it's even worse with mgo.
Why no one talk about that ?
Does it mean that no one is writing unit tests for mgo ?
What's not serious about this? :)
I have used mgo. I would never write unit tests for mgo because it's someone else's code. Dont test other people's code. Test your interaction with it.
But how?
For those who dont know, mgo is a mongo driver for Go.
Forget about different classes of test or whatever. You want a bit of your code that can talk to the mongo db such as
GetBankAccount(id string)
. Write a test for that. Inside it uses mgo, but that doesn't really matter, test the useful behaviour.Mocking mgo gives you so little in terms of confidence your system works and if you decide you want to refactor to use a different library you suddenly have a bunch of useless tests.
No one talks about it because it's too specific. You should be designing your software so that its as easy to test as the "not serious" examples you're reading.