Mocking amqp091-go difficulties with interfaces

I'm trying to write unit tests for a pared down and slightly modified version of the Go AMQP consumer https://github.com/rabbitmq/amqp091-go/blob/main/_examples/consumer/consumer.go for a simple utility to consume messages from a RabbitMQ queue and relay them to an AWS SQS queue. I'm having difficulties in mocking things like the Connection and Channel structs - quite new to Go - any ideas on how to go about this? I wrote a gist of the code in the playground - removing most of it to get down to the salient bits. The issue is this:

https://go.dev/play/p/ybSB6EU3siO

go: finding module for package github.com/rabbitmq/amqp091-go
go: downloading github.com/rabbitmq/amqp091-go v1.8.1
go: found github.com/rabbitmq/amqp091-go in github.com/rabbitmq/amqp091-go v1.8.1
# play
./prog.go:23:16: cannot use dial(url) (value of type *amqp091.Connection) as Connection value in assignment: *amqp091.Connection does not implement Connection (wrong type for method Channel)
		have Channel() (*amqp091.Channel, error)
		want Channel() (Channel, error)

Go build failed.

The actual func I'm trying to mock:
https://github.com/rabbitmq/amqp091-go/blob/579207b03cecc66c1b206679b79f267c8c734db7/connection.go#L843

Sample code to illustrate the issue.

package main

import amqp "github.com/rabbitmq/amqp091-go"

type Channel interface {
	Cancel(consumer string, noWait bool) error
}

type Connection interface {
	Channel() (Channel, error)
	Close() error
}

type Consumer struct {
	conn    Connection
	channel Channel
	tag     string
	done    chan error
}

func (c *Consumer) Consume(url string) error {
	var err error
	c.conn, err = dial(url)
	return err
}

var dial = func(url string) (*amqp.Connection, error) {
	return &amqp.Connection{}, nil
}

func main() {

}

// mocks in a test file

type mockConnection struct{}

func (m *mockConnection) Channel() (Channel, error) {
	return &mockChannel{}, nil
}

func (m *mockConnection) Close() error {
	return nil
}

type mockChannel struct{}

func (m *mockChannel) Cancel(consumer string, noWait bool) error {
	return nil
}

//dial = func(url string) (*mockConnection, error) {
//	return &mockConnection{}, nil
//}

So in the mock code I can use Channel instead of *mockChannel here:

func (m *mockConnection) Channel() (Channel, error) {
	return &mockChannel{}, nil
}

But clearly I can't change the amqp091 code to do so thus I'm stumped.

I see in rabbitmq/amqp091-go connection.go:

/*
Channel opens a unique, concurrent server channel to process the bulk of AMQP
messages.  Any error from methods on this receiver will render the receiver
invalid and a new Channel should be opened.
*/
func (c *Connection) Channel() (*Channel, error) {
	return c.openChannel()
}

But you have:

type Connection interface {
    Channel() (Channel, error)
    Close() error
}

I would prefer using MyConnection or MyChannel, just to avoid any confusion.
And using a dial function returning (MyConnection, error) instead of (*amqp.Connection, error): That would allow you to use either the real amqp connection or your mock connection in tests by assigning the dial function to return your mock implementation.

You can then use type assertions within your actual code to handle cases where you need to work with the real amqp091 structs.
For example:

func doSomethingWithChannel(channel MyChannel) {
    if realChannel, ok := channel.(*amqp.Channel); ok {
        // Do something with realChannel
    } else {
        // Handle mockChannel
    }
}

This allows you to write unit tests by mocking the Connection and Channel interfaces, while still being able to use the real amqp091 structs in your actual code.

However... That means your test code is leaking in your application code, which is not the best practice.

One way to avoid this is to have your production and test code both implement the same interface, and then in your actual code, you only interact with this interface.
This way, the actual code does not know anything about whether it is dealing with the real implementation or the mock, and you do not have any test code leaking into your actual application.

package main

import (
    "fmt"
    amqp "github.com/rabbitmq/amqp091-go"
)

// Define the interfaces
type MyChannel interface {
    Cancel(consumer string, noWait bool) error
}

type MyConnection interface {
    Channel() (MyChannel, error)
    Close() error
}

// Consumer struct
type Consumer struct {
    conn    MyConnection
    channel MyChannel
    tag     string
    done    chan error
}

func (c *Consumer) Consume(url string) error {
    var err error
    c.conn, err = dial(url)
    if err != nil {
        return err
    }
    c.channel, err = c.conn.Channel()
    return err
}

// Use function variable for dial so it can be overridden in tests
var dial = func(url string) (MyConnection, error) {
    conn, err := amqp.Dial(url)
    if err != nil {
        return nil, err
    }
    return &AMQPConnection{conn}, nil
}

// Wrappers around real amqp types to implement your interfaces
type AMQPConnection struct {
    *amqp.Connection
}

func (a *AMQPConnection) Channel() (MyChannel, error) {
    ch, err := a.Connection.Channel()
    if err != nil {
        return nil, err
    }
    return &AMQPChannel{ch}, nil
}

type AMQPChannel struct {
    *amqp.Channel
}

func (a *AMQPChannel) Cancel(consumer string, noWait bool) error {
    return a.Channel.Cancel(consumer, noWait)
}

func main() {
    c := &Consumer{}
    err := c.Consume("amqp://guest:guest@localhost:5672/")
    fmt.Println(err)
}

// In a separate _test.go file

type mockConnection struct{}

func (m *mockConnection) Channel() (MyChannel, error) {
    return &mockChannel{}, nil
}

func (m *mockConnection) Close() error {
    return nil
}

type mockChannel struct{}

func (m *mockChannel) Cancel(consumer string, noWait bool) error {
    return nil
}

In tests, you can override the dial function to return the mock implementations:

func TestConsumer(t *testing.T) {
    dial = func(url string) (MyConnection, error) {
        return &mockConnection{}, nil
    }
    // rest of your test code
}

That way, your production code does not have any knowledge of the test code, and it interacts only through the interface, which is implemented by both the real and mock versions.
The test code can inject the mock implementation by overriding the dial function.

To mock the closeChannel method for testing, you do not actually need to mock that specific method, but rather the structures and methods that would normally call it.

closeChannel is an unexported method of the Connection struct, which means it cannot be accessed directly from outside the package. This method is part of the internal logic of the amqp091-go library.

However, you can still test the behavior that relies on this method by mocking the public methods and structures that would interact with it.

In your test file:

type mockConnection struct {
    // ... you can keep state here if needed to simulate connection behavior ...
}

func (m *mockConnection) Channel() (MyChannel, error) {
    // Simulate behavior of opening a new channel
    return &mockChannel{}, nil
}

func (m *mockConnection) Close() error {
    // Simulate behavior of closing the connection, which would internally call closeChannel
    return nil
}

type mockChannel struct{}

func (m *mockChannel) Close() error {
    // Simulate behavior of closing the channel, which would internally call closeChannel
    return nil
}

func TestSomething(t *testing.T) {
    // Use the mockConnection in place of the real connection
    conn := &mockConnection{}
    
    // Your test logic here, e.g., opening and closing channels, and asserting the expected behavior
}

Your mock implementations simulate the behavior of the real Connection and Channel types.
Although this does not let you test the internal closeChannel method directly, it does allow you to test the behavior that relies on it by using the public interface.
This approach adheres to the best practices of unit testing, where you should test the public interface of a unit and not its internal implementation details.