[jlou2u]

Summary

Adds RunWithReturn which is essentially Run but adds Arguments as the return type and propagates them.

Used this as a starting point #742

Changes

• Adds RunWithReturn

Motivation

Helps write simple tests that can dynamically calculate return values.

Example (from test)

counter := 0
mockedService.On("TheExampleMethod", Anything, Anything, Anything).
	RunWithReturn(func(args Arguments) Arguments {
		counter++
		a, b, c := args[0].(int), args[1].(int), args[2].(int)
		assert.IsType(t, 1, a)
		assert.IsType(t, 1, b)
		assert.IsType(t, 1, c)
		return Arguments{counter}
	}).
	Twice()

answer, _ := mockedService.TheExampleMethod(2, 4, 5)
assert.Equal(t, 1, answer)

answer, _ = mockedService.TheExampleMethod(44, 4, 5)
assert.Equal(t, 2, answer)

Related issues

#742

[brackendawson]

This should override any previous calls to Return but also be overridden by any subsequent call to Return:

package kata_test

import (
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/mock"
)

type myMock struct {
	mock.Mock
}

func (m *myMock) Do() string {
	return m.Called().String(0)
}

func TestIfy(t *testing.T) {
	m := &myMock{}
	m.On("Do").Return("one").Return("two")
	assert.Equal(t, "two", m.Do())

	m = &myMock{}
	m.On("Do").Return("one").RunWithReturn(func(args mock.Arguments) mock.Arguments {
		return mock.Arguments{"two"}
	})
	assert.Equal(t, "two", m.Do())

	m = &myMock{}
	m.On("Do").RunWithReturn(func(args mock.Arguments) mock.Arguments {
		return mock.Arguments{"one"}
	}).Return("two")
	assert.Equal(t, "two", m.Do())
}

This is why I suggested calling it ReturnFn, so that folks understand its purpose to to set return values. The purpose of Run is to implement side effects.

[brackendawson]

Good work so far. 👍

This also causes Mock.Unset to misbehave:

	m = &myMock{}
	m.On("Do").ReturnFn(func(args mock.Arguments) mock.Arguments { return mock.Arguments{"one"} })
	m.On("Do").Return("two")
	m.On("Do").Return("two").Unset() // Unset is an awful Method
	assert.Equal(t, "one", m.Do())

Mock.Unset is using Arguments.Diff to find matching calls, but because Arguments is empty it implicitly matches. Unset should probably never match any Call when Call.ReturnArguments is empty and Call.returnFn is non-nil. Unset should probably panic when called on a Call when Call.ReturnArguments is empty and Call.returnFn is non-nil, this is because functions are not comparable.

[brackendawson]

The example should be valid Go, did you mean Int rather than Get?

Suggested change

	// return Arguments{args.Get(0) + args.Get(1)}
	// return Arguments{args.Int(0) + args.Int(1)}

[brackendawson]

Because call.ReturnArguments is exported it should probably be checked by this condition rather than returnFn, eg:

	m = &myMock{}
	m.On("Do").ReturnFn(func(args mock.Arguments) mock.Arguments { return mock.Arguments{"two"} })
	m.ExpectedCalls[0].ReturnArguments = mock.Arguments{"one"}
	assert.Equal(t, "one", m.Do())

ie. Call.ReturnArguments should always override Call.returnFn