Allow dynamic returns based on arguments

[alexandrevicenzi]

C# Moq allows to return data based on call arguments.

testify/mock don't. It's possible to do using Run, but it's a big mess of code.

It would be great to have something like this:

myMock.On("Load", mock.AnythingOfType("string")).ReturnFn(func (token string) (*MyObj, error) {
    if isValid(token) {
        return someStuff(), nil
    } else {
        return nil, errors.New("Oh!")
    }
})

I can send a PR if someone like this idea.

[ernesto-jimenez]

That example would not build since the func isn't returning anything.

Also, you can do:

myMock.On("Load", mock.MatchedBy(func (token string) bool { return !isValid(token) }).Return(nil, errors.New("invalid"))

[alexandrevicenzi]

@ernesto-jimenez I fixed the example.

I'll try your example.

[alexandrevicenzi]

@ernesto-jimenez the thing is, I need to return some value based on input.

I could use On with multiple times with multiple values. But my problem is when I don't know the expected param value. Assuming the example, token is a random UUID, it changes every call.

For this case there's almost no good way to return data based on input.

[ernesto-jimenez]

@alexandrevicenzi I'm struggling to see the use case. Why do you need some logic within that method?

If you are worried about asserting the mock is getting a valid token, you could do:

myMock.On("Load", mock.AnythingOfType("string")).Run(func(args mock.Arguments) { {
    assert.Equal(true, isValid(args.Get(0).(string)), "valid token expected")
})

Our mocks package currently cares only about inputs and outputs, rather than building custom outputs based on your own logic. If you want to have more complex mocks, you can build them easily and even leverage this package. Here is a quick example:

type yourCustomStruct struct {
    yourMock
}

func (s *yourCustomStruct) Load(token string) (*MyObj, error) {
    s.yourMock.Called(token) // <- this is assuming you want to do myMock.On("Load", ...) and then assert it has been called
    if  isValid(token) {
        return someStuff(), nil
    } else {
        return nil, errors.New("Oh!")
    }
}

yourCustomMock will have all the methods from yourMock through promotion, but Load will have some special logic. It has the extra bonus that you can reuse it across many tests instead of defining it within each test with myMock.On.

[alexandrevicenzi]

@ernesto-jimenez Yes, this works and it's reusable. But what if this logic must change in some scenario?

I know that I could create many On("Something") and return data based in the input provided in the arguments.

I was just thinking that this feature could be a good hack somewhere, for me it would be more easy to make a quick setup rather than creating multiples On("Something").

[ernesto-jimenez]

if you want different behaviors you can have different structs, or you could have the struct take a function:

type yourCustomStruct struct {
    yourMock
    loadFn func(string) (*MyObj, error)
}

func (s *yourCustomStruct) Load(token string) (*MyObj, error) {
    s.yourMock.Called(token) // <- this is assuming you want to do myMock.On("Load", ...) and then assert it has been called
    return s.loadFn(token)
}

[rayzyar]

@alexandrevicenzi looks like it's solved here https://github.com/vektra/mockery#return-value-provider-functions

[sivachandran]

@alexandrevicenzi @ernesto-jimenez I am trying to mock a file system like object on which I want to return some data on first call and return EOF on second call. Now to achieve this I have to write custom function in the mock object to track the no. of function calls which is already done by mock. If mock provides a way to call custom function passing all the information it has collected then it would be super useful.

[peterhuene]

In addition to the above reasons, I'd like to see this feature added so that I can mock an API returning a Reader that is expected to be invoked multiple times:

httpClient := new(mockHttpClient)
httpClient.On(
	"Do",
	mock.MatchedBy(func(req *http.Request) bool {
		// Do some logic to accept the request
		return true
	}
).Return(
	&http.Response{
		StatusCode: 200,
		Body:       ioutil.NopCloser(strings.NewReader("response data")),
	},
	nil,
).Times(10)

The problem here is that the Reader works just fine for the first invocation, but the second invocation is given the same Reader which is now at end-of-input. If there were a way to return a new Reader upon each invocation, this wouldn't be a problem.

Let's assume that the Times expectation is a large enough number that hand-rolling separate call expectations that return different response objects the "static way" is undesirable.

Following @ernesto-jimenez's workaround is sufficient, but a baked-in solution would be nice.

[ernesto-alvarado]

Almost any other mocking framework (even some golang ones) allows for this, what is the problem of having it also in this one?

[csmadhav]

I am also stuck here, I am trying to test a function which tries to push to the queue and tries 5 times, I want the mocked queue to return error first 3 times and success just after that. how can we achieve this with current implementation?

[brevno]

This snippet is slightly hacky, but works in existing testify API:

m := &mocks.UploadGetter{}
m.On("Get", mock.Anything).Run(func(args mock.Arguments) {
	for _, c := range m.ExpectedCalls {
		if c.Method == "Get" {
			c.ReturnArguments = mock.Arguments{uploadFromId(args[0].(string)), nil}
		}
	}
})

[hieuvo]

this was supported by testify already, it's RunFn

testify/mock/mock.go

Line 67 in 858f37f

RunFn func(Arguments)

sample code

	mockCall := mock.On("methodName", mock.Anything, mock.Anything)
	mockCall.RunFn = func(args mock.Arguments) {
		code := args[1].(string)
		...
		mockCall.ReturnArguments = mock.Arguments{nil, nil}
		}
	}

[andreib1]

@hieuvo
I might have missed something, but this isn't safe for concurrent code, as it isn't changing the return for the function instance, it is changing the return for the mock?