Dependency injection in Go

I'm looking for an appropriate way to inject dependencies.

Say I have this code where the FancyWrite and FancyRead functions have a dependency on the WriteToFile and ReadFromFile functions. Since these have side effects I'd like to be able to inject them so I can replace them in tests.

package main

func main() {
	FancyWrite()
	FancyRead()
}

////////////////

func FancyWrite() {
	WriteToFile([]byte("content..."))
}

func FancyRead() {
	ReadFromFile("/path/to/file")
}

////////////////

func WriteToFile(content []byte) (bool, error) {
	return true, nil
}

func ReadFromFile(file string) ([]byte, error) {
	return []byte{}, nil
}

One thing I tried is just put them as parameters into the functions:

package main

func main() {
	FancyWrite(WriteToFile)
	FancyRead(ReadFromFile)
}

////////////////

func FancyWrite(writeToFile func(content []byte) (bool, error)) {
	writeToFile([]byte("content..."))
}

func FancyRead(readFromFile func(file string) ([]byte, error)) {
	readFromFile("/path/to/file")
}

////////////////

func WriteToFile(content []byte) (bool, error) {
	return true, nil
}

func ReadFromFile(file string) ([]byte, error) {
	return []byte{}, nil
}

So, this actually works great, but I could see this becoming harder to maintain for more dependencies. I also tried a factory pattern like the following so that the main function doesn't have to concern itself with building the FancyWrite function. But, the syntax is getting a little hard to read and with even more functions would be hard to maintain.

func FancyWriteFactory(writeToFile func(content []byte) (bool, error)) func() {
	return func() {
		FancyWrite(writeToFile)
	}
}

So next I tried housing the functions as methods in a struct:

package main

func main() {
	dfu := DefaultFileUtil{}
	ffm := FancyFileModule{
		FileUtil: &dfu,
	}

	ffm.FancyWrite()
	ffm.FancyRead()
}

////////////////

type FileUtil interface {
	WriteToFile(content []byte) (bool, error)
	ReadFromFile(file string) ([]byte, error)
}

type FancyFileModule struct {
	FileUtil
}

func (fm *FancyFileModule) FancyWrite() {
	fm.FileUtil.WriteToFile([]byte("content..."))
}

func (fm *FancyFileModule) FancyRead() {
	fm.FileUtil.ReadFromFile("/path/to/file")
}

////////////////

type DefaultFileUtil struct{}

func (fu *DefaultFileUtil) WriteToFile(content []byte) (bool, error) {
	return true, nil
}

func (fu *DefaultFileUtil) ReadFromFile(file string) ([]byte, error) {
	return []byte{}, nil
}

Now, this actually works well and is cleaner. However, I'm worried I am just shoehorning my functions as methods now and something just felt odd about that. I guess I can reason about it because structs are good when you have some state, and I guess I can count the dependencies as state?

Those are the things I tried. So my question is, what is the proper way to do dependency injection in this case when the only reason to put functions as methods is to make them be a collection of dependencies elsewhere?

Thanks!

The simple answer is that you cannot cleanly use dependency injection with functions, only with methods. Technically, you could make the functions global vars instead (ex. var WriteToFile = func(content []byte) (bool, error) { [...] }), but this is rather brittle code.

The more proper solution, from an idiomatic perspective, is to make any behavior you want to replace, inject, or wrap into a method that is then wrapped in an interface.

For example:

type (
    FancyReadWriter interface {
        FancyWrite()
        FancyRead()
    }

    fancyReadWriter struct {
        w Writer
        r Reader
    }
    
    Writer interface {
        Write([]byte) (bool, error)
    }

    Reader interface {
        Read() ([]byte, error)
    }

    fileWriter struct {
        path string
        // or f *os.File
    }

    fileReader struct {
        path string
        // or f *os.File
    }
)

func (w fileWriter) Write([]byte) (bool, error) {
    // Write to the file
    return true, nil
}

func (r fileReader) Read() ([]byte, error) {
    // Read from the file
    return nil, nil
}

func (f fancyReadWriter) FancyWrite() {
    // I like to be explicit when I'm ignoring return values, 
    // hence the underscores.
    _, _ = f.w.Write([]byte("some content..."))
}

func (f fancyReadWriter) FancyRead() {
    _, _ = f.r.Read()
}

func NewFancyReadWriter(w Writer, r Reader) FancyReadWriter {
    // NOTE: Returning a pointer to the struct type, but it is actually
    // returned as an interface instead, abstracting the underlying
    // implementation.
    return &fancyReadWriter{
        w: w,
        r: r,
    }
}

func NewFileReader(path string) Reader {
    // Same here, returning a pointer to the struct as the interface
    return &fileReader {
        path: path
    }
}

func NewFileWriter(path string) Writer {
    // Same here, returning a pointer to the struct as the interface
    return &fileWriter {
        path: path
    }
}

func Main() {
    w := NewFileWriter("/var/some/path")
    r := NewFileReader("/var/some/other/path")
    f := NewFancyReadWriter(w, r)

    f.FancyWrite()
    f.FancyRead()
}

And then in the test file (or wherever you want to do the dependency injection):

type MockReader struct {}

func (m MockReader) Read() ([]byte, error) {
    return nil, fmt.Errorf("test error 1")
}

type MockWriter struct {}

func (m MockWriter) Write([]byte) (bool, error) {
    return false, fmt.Errorf("test error 2")
}

func TestFancyReadWriter(t *testing.T) {
    var w MockWriter
    var r MockReader
    f := NewFancyReadWriter(w, r)
    
    // Now the methods on f will call the mock methods instead
    f.FancyWrite()
    f.FancyRead()
}

You could then go a step further and make the mock or injection framework functional and thus flexible. This is my preferred style for mocks for tests, actually, as it lets me define the behavior of the mocked dependency within the test using that behavior. Example:

type MockReader struct {
    Readfunc func() ([]byte, error)
    ReadCalled int
}

func (m *MockReader) Read() (ret1 []byte, ret2 error) {
    m.ReadCalled++
    if m.Readfunc != nil {
        // Be *very* careful that you don't just call m.Read() here.
        // That would result in an infinite recursion.
        ret1, ret2 = m.Readfunc()
    }

    // if Readfunc == nil, this just returns the zero values
    return 
}

type MockWriter struct {
    Writefunc func([]byte) (bool, error)
    WriteCalled int
}

func (m MockWriter) Write(arg1 []byte) (ret1 bool, ret2 error) {
    m.WriteCalled++
    if m.Writefunc != nil {
        ret1, ret2 = m.Writefunc(arg1)
    }

    // Same here, zero values if the func is nil
    return 
}

func TestFancyReadWriter(t *testing.T) {
    var w MockWriter
    var r MockReader

    // Note that these definitions are optional.  If you don't provide a
    // definition, the mock will just return the zero values for the
    // return types, so you only need to define these functions if you want
    // custom behavior, like different returns or test assertions.

    w.Writefunc = func(d []byte) (bool, error) {
        // Whatever tests you want, like assertions on the input or w/e
        // Then whatever returns you want to test how the caller handles it.
        return false, nil
    }

    r.Readfunc = func() ([]byte, error) {
        return nil, nil
    }

    // Since the mocks now define the methods as *pointer* receiver methods,
    // so the mock can keep track of the number of calls, we have to pass in
    // the address of the mocks rather than the mocks as struct values.
    f := NewFancyReadWriter(&w, &r)
    
    // Now the methods on f will call the mock methods instead
    f.FancyWrite()
    f.FancyRead()

    // Now you have a simple way to assert that the calls happened:
    if w.WriteCalled < 1 {
        t.Fail("Missing expected call to Writer.Write().")
    }

    if r.ReadCalled < 1 {
        t.Fail("Missing expected call to Reader.Read().")
    }
}

Since all of the types involved here (the Reader, Writer, and the FancyReadWriter) are all handed around as interfaces rather than concrete types, it also becomes trivial to wrap them with middleware or similar (ex. logging, metrics/tracing, timeout aborts, etc).

This is hands down the most power strength of Go's interface system. Start thinking of types as bags of behavior, attach your behavior to types that can hold them, and pass all behavior types around as interfaces rather than concrete structs (data structs that are just used to organize specific bits of data are perfectly fine without interfaces, else you have to define Getters and Setters for everything and it's a real chore without much benefit). This lets you isolate, wrap, or entirely replace any particular bit of behavior you want at any time.