How do I elegantly test a method in Go that wraps multiple clients? - unit-testing

Question

I have a Client struct that wraps several clients (etcd and libvirt). Something like:
type Client struct {
etcd *clientv3
libvirt *libvirt.Connect
}
Once a client of my library wants to close its handle, I want to close both of these. So I have:
func (c *Client) Close() error {
c.etcd.Close()
c.libvirt.Close()
// Error handling excluded for brevity
}
What would be an elegant way to test this? My current best bet is to create two interfaces, one for each of the two wrapped clients. Those interfaces would include every single method from the two clients that my library uses. That should make it relatively easy to pass a mock of some sort instead of the real clients. This may be the way forward, but it feels awkward.
What are my other options?

Answer 1

As I mentioned in the comment, you can create a ClosableClient as shown below. Since each of your client will have Close method, you can do this. In your test file, you can create mock clients which have to only implement Close method. You don't need to make the interface implement all methods. In your code, you can use type assertion to convert the ClosableClient into specific client to access its functions. Here is a good example of type assertion.
I have added code snippet to show how you can use type assertion to get the underlying struct. Your mock clients in the test file need not implement Foo and Bar methods as the interface ClosableClient only needs Close method.
type ClosableClient interface {
Close()
}
type Etcd struct{}
func (e *Etcd) Close() {
fmt.Println("etcd closing")
}
func (e *Etcd) Foo() {
fmt.Println("etcd foo")
}
type Libvirt struct{}
func (l *Libvirt) Close() {
fmt.Println("libvirt closing")
}
func (l *Libvirt) Bar() {
fmt.Println("libvirt bar")
}
type Client struct {
etcd ClosableClient
libvirt ClosableClient
}
func (c *Client) Close() {
c.etcd.Close()
c.libvirt.Close()
}
func (c *Client) FooBar() {
etcd, ok := c.etcd.(*Etcd)
if !ok {
panic("etcd is of incorrect type")
}
etcd.Foo()
libvirt, ok := c.etcd.(*Libvirt)
if !ok {
panic("libvirt is of incorrect type")
}
libvirt.Bar()
}

Answer 2

Encouraged by poWar's comment that my idea was good, I went ahead like this:
I changed my Client struct to use interfaces for my libvirt and etcd connections:
type EtcdClient interface {
}
type LibvirtClient interface {
}
type Client struct {
etcd EtcdClient
libvirt LibvirtClient
}
When I tried to compile the package, I get an error message sort of like this:
./main.go:17:18: c.etcd.Close undefined (type EtcdClient is interface with no methods)
./main.go:21:24: c.libvirt.Close undefined (type LibvirtClient is interface with no methods)
Not surprising. I then added the simplest possible Close() method to the interfaces:
type EtcdClient interface {
Close()
}
type LibvirtClient interface {
Close()
}
Compiling once again gave me:
./main.go:56:10: cannot use etcd (type *clientv3.Client) as type EtcdClient in assignment:
*clientv3.Client does not implement EtcdClient (wrong type for Close method)
have Close() error
want Close()
./main.go:62:13: cannot use lv (type *libvirt.Connect) as type LibvirtClient in assignment:
*libvirt.Connect does not implement LibvirtClient (wrong type for Close method)
have Close() (int, error)
want Close()
And then I used that to fill in the interface definitions:
type EtcdClient interface {
Close() error
}
type LibvirtClient interface {
Close() (int, error)
}
Of course, Close was simple enough that I didn't have to go through this, but as I mentioned earlier, I'm calling many methods on these interfaces, and this way made it pretty simple to have the compiler help me fill in the interface definitions.
For the tests, I could then make fakes (mocks? stubs? I always forget the difference). Here is the test file in its entirety:
package main
import (
"errors"
"testing"
)
type FakeEtcdClient struct {
wasClosed bool
failToClose bool
}
func (f *FakeEtcdClient) Close() error {
if f.failToClose {
return errors.New("Fake Etcd failed to Close")
}
f.wasClosed = true
return nil
}
type FakeLibvirtClient struct {
wasClosed bool
failToClose bool
}
func (f *FakeLibvirtClient) Close() (int, error) {
if f.failToClose {
return 0, errors.New("Fake libvirt failed to Close")
}
f.wasClosed = true
return 0, nil
}
func TestClient_Close(t *testing.T) {
type fields struct {
etcd EtcdClient
libvirt LibvirtClient
}
tests := []struct {
name string
fields fields
wantErr bool
}{
{"Happy path", fields{&FakeEtcdClient{}, &FakeLibvirtClient{}}, false},
{"Etcd fails", fields{&FakeEtcdClient{failToClose: true}, &FakeLibvirtClient{}}, true},
{"Libvirt fails", fields{&FakeEtcdClient{}, &FakeLibvirtClient{failToClose: true}}, true},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
c := &Client{
etcd: tt.fields.etcd,
libvirt: tt.fields.libvirt,
}
if err := c.Close(); (err != nil) != tt.wantErr {
t.Errorf("Client.Close() error = %v, wantErr %v", err, tt.wantErr)
} else {
if !tt.wantErr {
// We only check if the clients have been closed if
// Client.Close() returns successfully.
if !c.etcd.(*FakeEtcdClient).wasClosed {
t.Error("Etcd connection was not closed")
}
if !c.libvirt.(*FakeLibvirtClient).wasClosed {
t.Error("Libvirt connection was not closed")
}
}
}
})
}
}