golang 单元测试中的 Mocking 特定错误类型

Question

I have been working on handling soft failures in some golang functions, and want to create some unit tests for the various failure scenarios. For example some of the checks include:

        switch err := err.(type) {
        case net.Error:
                if err.(net.Error).Temporary() || err.(net.Error).Timeout() {
                        ...
                }
        case *url.Error:
                if err, ok := err.Err.(net.Error); ok && err.Timeout() {
                        ...
                }
        case *net.OpError:
                if syscallErr, ok := err.Err.(*os.SyscallError); ok {
                        if syscallErr.Err == syscall.ECONNRESET {
                                ...
                        }
                }
        ...

I believe I just need my mock function to return errors compatible with those conditions. I see net.Error, net.OpError, url.Error, and os.SyscallError types exported. However I can't find any examples of anyone constructing a net.Error value and returning it - people put a lot of work into creating an external processes that fail in various ways but no examples of returning a net.Error with a Timeout function that returns true.

Likewise I could not find any examples of wrapping an error that wasn't produced with fmt.Errorf so I'm unsure if something more then errors.Wrap() is involved when not using the base builtin error type.

Answer 1

https://golang.org/pkg/net/#Error is an interface , and defining Timeout and Temporary would be trivial since they just return bool .

package main

import(
        "fmt"
        "net"
)

type mockNetError struct {
        temporary bool
        timeout bool
}

func (e *mockNetError)Error() string {
        return fmt.Sprintf("mockNetworkError: timeout %b, temporary %b", e.timeout, e.temporary)
}

func (e *mockNetError)Temporary() bool{
        return e.temporary
}

func (e *mockNetError)Timeout() bool{
        return e.timeout
}
func main() {
        var err error = new(mockNetError)
        if nerr, ok := err.(net.Error); ok {
                fmt.Println("It was a network error! %s", nerr.Error())
        }
}

However, because net.Error is an interface type, err.(type) will never return it. In my code, I assert that it might satisfy that interface, which is different from asking whether it is the type of the value in the err interface.

The other errors you mention from net are not interfaces (though they do satisfy net.Error ).

https://blog.golang.org/go1.13-errors talks about how error wrapping works in go.

a convention rather than a change: an error which contains another may implement an Unwrap method returning the underlying error.

the reason %w is almost always the way it's done is because folks are almost always adding additional text to the error.

In fact, net.OsError is an example of an error that can wrap another by providing an Unwrap() method.

If you want to create such an error, just:

fmt.Println(net.OpError{
   Op: "mock", 
   Net: "mock",
   Source: &net.TCPAddr{IP: net.ParseIP("127.0.0.1"), Port: 1234 },                
   Addr: &net.TCPAddr{IP: net.ParseIP("127.0.0.1"), Port: 12340 },
   Err: fmt.Errorf("Mock net.OpError"),
})

Answer 2

Building on the answer from Daniel Farrell, I found an example of mocking an os.SyscallError buried deep in the AWS SDK for Golang. Putting them together we get this:

return nil, &net.OpError{
                Op:     "mock",
                Net:    "mock",
                Source: &net.TCPAddr{IP: net.ParseIP("127.0.0.1"), Port: 1234},
                Addr:   &net.TCPAddr{IP: net.ParseIP("127.0.0.1"), Port: 12340},
                Err:    &os.SyscallError{Syscall: "read", Err: syscall.ECONNRESET},
               }