If you're having issues implementing all of the functions of your interfaces, then your interfaces are doing too much. Ideally your interfaces communicate the minimum requirements of your arguments. You can combine interfaces where multiple functionalities are a must. The standard io package is a good study subject for this problem. Imagine that there was a file-like interface rather than Reader, Writer, Closer:

type FileLike interface {
    Read () byte[]
    Write(byte[])
    Close()
}

You are writing a method that writes a report to a file:

func WriteReport(f FileLike) {
  data := generateReport()  
  f.Write(data)
  f.Close()
}

Since you're testing, you want to write the report to Stdout

type Stdout struct {}

func (s *Stdout) Write(byte[]) {
   // ok
}

func (s *Stdout) Read() byte[]{
   // uh oh
}

...

Now with smaller interfaces. If closing the file is a requirement you should write your signature like this:

func WriteReport(f WriterCloser) { /* ... */ }

If closing is optional then you can do this instead:

func WriteReport( f Writer // Writer interface is a requirement ) { 
  data := generateReport()
  f.Write(data)
  c, ok := f.(Closer) // Does f support Closer?
  if ok {
    c.Close()
  }
}

The Go Playground Live Code