Can I mock a function with pointer parameter which need to be used

Question

Let's say we have a library provide a function Double to double the integer, we use pointer i to get the result value not by return:

package api

type Action interface {
    Double(i *int) error
}

type NUM struct{}

func (n NUM) Double(i *int) error {
    *i *= 2

    return nil
}

in our main function we use this library to do our task. like this:

package app

import (
    "fmt"
    "github.com/hotsnow/api"
)

func main() {
    j := job{a: &api.NUM{}}
    d := j.task(3)
    fmt.Println(3, d)
}

type job struct {
    a api.Action
}

// double me
func (j job) task(i int) int {
    j.a.Double(&i)

    return i
}

Now we need to test the task() function, how can we get the pointer return bye mock the Double function?

Here is the test:

package app

import (
    "github.com/golang/mock/gomock"
    "github.com/hotsnow/mocks"
    "testing"
)

func TestReq(t *testing.T) {
    ctrl := gomock.NewController(t)
    defer ctrl.Finish()

    m := mocks.NewMockAction(ctrl)
    m.EXPECT().Double(gomock.Any()).Return(nil)

    j := job{a: m}
    got := j.task(3)
    if got != 6 {
        t.Errorf("got = %#v; want 6", got)
    }
}

The code here: https://github.com/hotsnow/mock.git (stackoverflow branch)

score 7 · Answer 1 · answered Sep 04 '20 at 08:49

7

you can use gomock setarg function for this

yourPackage.EXPECT().insert(&pointer).SetArg(0, newPointer)

answered Sep 04 '20 at 08:49

PhantomX7

71
1
2

score 2 · Answer 2 · answered Oct 12 '21 at 11:55

You can achieve this with the provided Eq() matcher, which internally calls reflect.DeepEqual() on the expected and actual values; as per the documentation for this method:

Pointer values are deeply equal if they are equal using Go's == operator or if they point to deeply equal values.

Say we have a function that depends upon an interface method that takes a pointer parameter:

package resource

type ServiceRequest struct {
    Name  string
    Owner *string // this is a pointer so it can be omitted with `nil`
}

type Model struct {
    // resource model...
}

type ResourceService interface {
    Fetch(req *ServiceRequest) (Model, error)
}

type getResourceHandler struct {
    resourceService ResourceService
}

type GetResourceEvent struct {
    Resource string
    Owner    *string
}

func NewResourceHandler(resourceService ResourceService) *getResourceHandler {
    return &getResourceHandler{resourceService}
}

func (h *getResourceHandler) Handle(event GetResourceEvent) (Model, error) {
    return h.resourceService.Fetch(&ServiceRequest{event.Resource, event.Owner})
}

We can use the Eq() matcher when setting up the expectation against our generated mock of the ResourceService interface:

package test

import (
    "testing"

    "github.com/golang/mock/gomock"
    "github.com/stretchr/testify/assert"

    "github.com/org/repo/internal/mock"
    "github.com/org/repo/internal/resource"
)

func optionalString(str string) *string {
    return &str
}

func Test_GetResourceHandler_ReturnsResultFromService(t *testing.T) {
    resourceName := "my-resource"
    owner := optionalString("Joe Bloggs")
    resourceReq := &resource.ServiceRequest{resourceName, owner}
    event := resource.GetResourceEvent{resourceName, owner}
    model := resource.Model{ /* fields here... */ }

    ctrl := gomock.NewController(t)
    mockResourceService := mock.NewMockResourceService(ctrl)
    handler := resource.NewResourceHandler(mockResourceService)

    mockResourceService.EXPECT().Fetch(gomock.Eq(resourceReq)).Return(model, nil)

    res, err := handler.Handle(event)

    assert.Nil(t, err)
    assert.Equal(t, model, res)
}

If you change the contents of the service request in either the test or the unit under test, you'll see that the test no longer passes. Otherwise, it will pass in spite of the test and the unit under test having their own respective pointers to separate ServiceRequest{} values.

score 0 · Answer 3 · answered Dec 18 '19 at 03:58

0

It seems you don't have to use gomock to test the task method.

Since you have an interface, why not just create a mock implementation of the interface, for example:

type dummy struct{
    callCount int
}

func (d *dummy) Double(i *int) error {
    d.callCount++
    return nil
}

d := dummy{}
j := job{a: &d}
got := j.task(3)
if d.callCount != 1 {
    // XXX
}

answered Dec 18 '19 at 03:58

satoru

31,822
31
91
141

Thanks for you answer. this works for here. But in real word, we need to implement all the methods for this interface. and will lost the flexibility of gomock, eg: Matcher – hotsnow Dec 18 '19 at 04:16
I don't think so. Most of the time you only needs dummy implementation of one of the methods, by embedding the interface in the `dummy` struct, you only have to implement the methods you care. – satoru Dec 19 '19 at 01:46
I got your point after some learning and testing. But I still want to know if gomock can change the pointer parameter or not. Thanks. – hotsnow Jan 05 '20 at 00:22

Can I mock a function with pointer parameter which need to be used

3 Answers3