Mocking a type where interface signature's types are also mocked

I'm trying to write a wrapper around an existing library that I do not want to edit, while allowing testing via mocking.

To allow for testing and mocking, I have created interfaces that satisfy the type signatures of the existing library and am using mockgen. I must also mock some of the types returned by the functions in these interface type signatures.

However, doing this causes the interface to no longer satisfy the existing library.

Example:

I have a ClientType, this has a function Subscribe, which returns a SubscriptionType.

func NewClientType() ClientType {
	return ClientType{"project name"}
}

type ClientType struct {
	projectID string
}

func (l *ClientType) Subscribe(subID string) SubscriptionType {
	return SubscriptionType{subID}
}

type SubscriptionType struct {
	subscriptionID string
}

func (t *SubscriptionType) Receive() {
	fmt.Println("Stuff")
}

I want to mock the Receive method.

This will allow me to create a Client, Subscribe it to a topic, and then mock this Receiving a message in testing.

I tried:

type MyLibraryWrapper struct {
	ClientType
}

type MockedClientType interface {
	Subscribe(string) MockedSubscriptionType
}

type MockedSubscriptionType interface {
	Receive()
}

func main() {
	client := NewClientType()

	myMockedType := NewWrapper(client)
	sub := myMockedType.Subscribe("a")
	_ = sub // use it
}

func NewWrapper(client ClientType) MyLibraryWrapper {
	return MyLibraryWrapper{client}
}

That gives:

<!-- language: lang-none -->

cannot use client (type ClientType) as type MockedClientType in argument to NewWrapper:
	ClientType does not implement MockedClientType (wrong type for Subscribe method)
		have Subscribe(string) SubscriptionType
		want Subscribe(string) MockedSubscriptionType

Live demo:

https://go.dev/play/p/6Pr_Y4VtOAW

Your library API is hardcoded to return structs. You have to wrap each of its struct in an interface first before you can mock anything.

With embedding that task becomes easier.

type MyLibraryWrapper struct {
	ClientType
}

type MyClientType interface {
	Subscribe(string) MySubscriptionType
}

type MySubscriptionType interface {
	Receive()
}

func NewWrapper(client ClientType) MyClientType {
	return MyLibraryWrapper{client}
}

Now you can mock it...

type MockLibraryWrapper struct {}

type MockSubscriptionType struct {}

func (MyMockLibraryWrapper) Subscribe(string) MySubscriptionType {
	return MockSubscriptionType{}
}

func (MockSubscriptionType) Receive() {}

func NewMockClientType() MyClientType {
	return MockLibraryWrapper{}
}

Example usage:

func main() {
	realClient := NewWrapper(NewClientType())
	sub := realClient.Subscribe("a")
	sub.Receive()

	mockClient := NewMockClientType()
	sub := mockClient.Subscribe("a")
	sub.Receive()
}