Typed expected mocks

[mesirendon]

Hi everyone, here's the thing

If I write an interface with a given method, the generated mock includes the expecter. It's useful to check on the number of parameters the mock is supposed to receive. However, the parameters are interface-typed. And at, the same time, the return knows perfectly well what the type of the results are.

I don't know how to force the expecter to have specific types of parameters instead of interfaces. If not, I think it would be nice to have mock parameters typed as stated in the original interfaces.

An example here to give context.

If I define the following interface

type (
	entityRepositoryDbClient interface {
		UpdateItem(
			ctx context.Context,
			params *dynamodb.UpdateItemInput,
			optFns ...func(*dynamodb.Options),
		) (*dynamodb.UpdateItemOutput, error)
	}
)

It generates the following mock related expecter:

// UpdateItem is a helper method to define mock.On call
//   - ctx context.Context
//   - params *dynamodb.UpdateItemInput
//   - optFns ...func(*dynamodb.Options)
func (_e *mockEntityRepositoryDbClient_Expecter) UpdateItem(ctx interface{}, params interface{}, optFns ...interface{}) *mockEntityRepositoryDbClient_UpdateItem_Call {
	return &mockEntityRepositoryDbClient_UpdateItem_Call{Call: _e.mock.On("UpdateItem",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *mockEntityRepositoryDbClient_UpdateItem_Call) Run(run func(ctx context.Context, params *dynamodb.UpdateItemInput, optFns ...func(*dynamodb.Options))) *mockEntityRepositoryDbClient_UpdateItem_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*dynamodb.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*dynamodb.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*dynamodb.UpdateItemInput), variadicArgs...)
	})
	return _c
}

func (_c *mockEntityRepositoryDbClient_UpdateItem_Call) Return(_a0 *dynamodb.UpdateItemOutput, _a1 error) *mockEntityRepositoryDbClient_UpdateItem_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *mockEntityRepositoryDbClient_UpdateItem_Call) RunAndReturn(run func(context.Context, *dynamodb.UpdateItemInput, ...func(*dynamodb.Options)) (*dynamodb.UpdateItemOutput, error)) *mockEntityRepositoryDbClient_UpdateItem_Call {
	_c.Call.Return(run)
	return _c
}

[LandonTClipp]

This is a known "problem". The issue is that we may need to specify mock.Anything which can't be done if the arguments are strictly typed. I do want to add a feature that allows mock methods to be strictly typed, but I have not had the time to do this and there is even a debate on whether this style of expectation mocks is the way of the future. See: #725

If anyone would be willing to implement strictly typed arguments, I will 100% approve it. But given how this introduces confusion on how to specify mock.Anything, it's just an awkward situation that would require clear documentation.

[mesirendon]

I was thinking about this.
It's not necessary to modify the expecter. It could stay interface-typed. What about having an expecter-like type that actually defines the actual types?

In that case you can have

mockedInterface.EXPECT().YourMethod(context.Background()) // this one is interface-typed

But also have

mockedInterface.TYPED().YourMethod(context.Background()) // this one is actually typed