Mockery pass constructor arguments - is this a bug/feature-request?

[mastacheata]

Hey there,

the built-in helper-method from Laravel expects a Closure and only a Closure as a second parameter after the FQCN to be mocked.

There's 2 things that bother me about this:

1. Passing a callback to Mockery::mock is an undocumented Feature of Mockery
2. The official docs actually say the second parameter to Mockery::mock is an array of arguments to pass to the mocked class' constructor. The Laravel helper removes this feature in favor of the scoped-closure by way of specifying the argument types, but the implementation is perfectly set up to pass along arbitrary parameters to Mockery.

Was this intended to both shadow and change the behavior of the original call or is this maybe some legacy feature of Mockery that's now been superceded?
I would really love to have the documented behavior of passing the constructor arguments along without having to go the full manual route.

[henzeb]

Mockery is a third-party package. Have you asked your question there as well?

[mastacheata]

I think you misunderstood my question.

The helper functions included in Laravel ($this->mock, $this->partialMock and $this->spy) are basically a wrapper around Mockery that a) calls the corresponding static Mockery function and b) binds the generated mock to the container.

My concern is only with this particular wrapper, not the underlying functionality of Mockery. (see: https://github.com/laravel/framework/blob/10.x/src/Illuminate/Foundation/Testing/Concerns/InteractsWithContainer.php#L61)

The Laravel-internal function accepts exactly 2 arguments: A string identifying the thing to mock (FQCN or FQCN with one of Mockery's magic prefixes)

Mockery allows an arbitrary number of arguments to be given to the Mockery::mock function and the will Wrap the call in a given Closure if and only if that Closure is the very last argument.

In Laravel you can do:
$this->mock('SomeClassName', function () { /* do stuff */ });
which in turn will call $this->instande('SomeClassName', \Mockery::mock('SomeClassName', function () { /* do stuff */ });

If the type hints weren't restricting the second parameter to a Closure and one would instead use a variadic as the second parameter without changing the behaviour of the functions at all, one could now do:
$this->mock('SomeClassName', ['classConstructorArgument1'], function () { /* do stuff */ });

The $this->mock helper is already set up to accept an arbitrary number of arguments and pass them to Mockery, but the function header restricts that.

I would like to make use of the advanced features of Mockery that "live" in the parameters between the first and the last one, while still retaining the Laravel Helper's comfort functionality of binding the Mocked Class to the container.

[mastacheata]

Also: Just discovered that the callback behaves completely different to what I had expected from the documentation.

The binding of the Mocked Class to the container happens outside of the Closure. Within the Closure it's not bound.

I guess that's why the only test for the mock helpers doesn't even use the syntax as shown in the Laravel docs. 😱