Dependency Injection in Go with Tests

Hey there! 👋 Let’s talk about dependency injection (DI) in Go.

Sounds fancy, right?

But don’t worry—it’s actually pretty simple (and super useful).

Why Should You Care? 🤔

• No frameworks needed (Go keeps it lightweight).
• Makes testing easier (no more fighting with stdout).
• Keeps your code flexible (write once, use anywhere).

Let’s Start with a Simple Example

Imagine we have a Greet function that prints a friendly message:

func Greet(name string) {
    fmt.Printf("Hello, %s", name)
}

But how do we test this? fmt.Printf writes directly to the terminal, which is hard to check in a test.

The Problem? Tight Coupling 🔗

Our function is stuck printing to stdout. What if we want to:

• Test the output?
• Send the greeting to a file?
• Output it in an HTTP response?

The Solution? Dependency Injection! 🎉

Instead of hardcoding fmt.Printf, we can pass in where the output should go.

How? Use io.Writer!

Go’s io.Writer is an interface that says:

“Hey, I can write bytes somewhere!”

Many things implement io.Writer:

• Files (os.File)
• HTTP responses (http.ResponseWriter)
• Even a simple buffer (bytes.Buffer) for testing!

Let’s Refactor 🛠

Step 1: Rewrite Greet to Accept a Writer

func Greet(writer io.Writer, name string) {
    fmt.Fprintf(writer, "Hello, %s", name) // Fprintf takes a Writer!
}

Step 2: Test It with a Buffer

func TestGreet(t *testing.T) {
    buffer := bytes.Buffer{}
    Greet(&buffer, "Chris")

    got := buffer.String()
    want := "Hello, Chris"

    if got != want {
        t.Errorf("got %q want %q", got, want)
    }
}

func TestGreetEmptyName(t *testing.T) {
    buffer := bytes.Buffer{}
    Greet(&buffer, "")

    got := buffer.String()
    want := "Hello, "

    if got != want {
        t.Errorf("got %q want %q", got, want)
    }
}

func TestGreetUnicodeName(t *testing.T) {
    buffer := bytes.Buffer{}
    Greet(&buffer, "世界")

    got := buffer.String()
    want := "Hello, 世界"

    if got != want {
        t.Errorf("got %q want %q", got, want)
    }
}

✅ Now we can test various cases without printing to the terminal!

Step 3: Use It in Real Life

func main() {
    Greet(os.Stdout, "Elodie") // Prints to terminal
}

Or even in an HTTP handler!

func MyGreeterHandler(w http.ResponseWriter, r *http.Request) {
    Greet(w, "world") // Writes to HTTP response
}

Key Takeaways 🗝

1. DI makes testing easy – Swap real dependencies (like stdout) with test-friendly ones (like bytes.Buffer).
2. Decouple your code – Separate what your function does from where the output goes.
3. Reuse everywhere – The same Greet function works in CLI apps, web servers, and tests!

But Wait… What About Mocking? 😱

Mocking is useful (and not evil, I promise!), but sometimes the standard library already gives you what you need.

Pro Tip: Study io.Writer 📚

The more you know about Go’s interfaces (io.Reader, io.Writer, etc.), the more flexible your code becomes!

Next Up: Mocking – Because sometimes you do need to fake it till you make it.