How to test pubsub message acknowledgement in go? - unit-testing

Question

How to write a unit test which would verify that the message is actually being acked ?
I would like to mock the pubsub message and verify that Ack is called but cant't realize how.
func processMessage(ctx context.Context, msg *pubsub.Message) {
log.Printf("Processing message, data: %s", msg.Data)
msg.Ack()
}

Answer 1

You can do that by using interface and mocking as follows.
// Create an interface that'll be implemented by *pubsub.Message
type message interface{
Ack()
}
// Accept the interface instead of the concrete struct
func processMessage(ctx context.Context, msg message) {
log.Printf("Processing message, data: %s", msg.Data)
msg.Ack()
}
Now, in the test files, create a mocked message and confirm whether Ack is being called. You can use testify/mock for that.

Answer 2

You can create an interface that wraps the message and a function that wraps the receive function type.
// message interface to pass to our message handler
type Message interface {
GetData() []byte
Ack()
}
// real message for pubsub messages
type msg struct {
m *pubsub.Message
}
// returns real message data
func (i *msg) GetData() {
return i.m.Data
}
// acks the real pubsub message
func (i *msg) Ack() {
i.m.Ack()
}
// test message can be passed to the handleMessage function
type testMsg struct {
d []byte
}
// returns the test data
func (t *testMsg) GetData() []byte {
return d
}
// does nothing so we can test our handleMessage function
func (t *testMsg) Ack() {}
func main() {
client, err := pubsub.NewClient(context.Background(), "projectID")
if err != nil {
log.Fatal(err)
}
sub := client.Subscription("pubsub-sub")
sub.Receive(ctx, createHandler())
}
// creates the handler, allows us to pass our interface to the message handler
func createHandler() func(ctx context.Context, m *pubsub.Message) {
// returns the correct function type but uses our message interface
return func(ctx context.Context, m *pubsub.Message) {
handleMessage(ctx, &msg{m})
}
}
// could pass msg or testMsg here because both meet the interface Message
func handleMessage(ctx context.Context, m Message) {
log.Println(m.GetData())
m.Ack()
}