Mocking Static Methods in PHP - unit-testing

Question

My goal is to be able to write unit tests for static methods that advocate:
Maintainability - I want the code to be as easy to follow, understand, and debug over time.
Performance - I'd like the speed of our tests not to suffer due to our technical debt if possible.
Constraints: We cannot refactor the static method to be an instance method. That would be first thing I would probably suggest, but I'm looking for an options/alternatives and opinions.
Testing static methods is a bit of a pain. There was a time that we could do this with phpunit. Mockery supports a means to test static methods through aliasing, but its not recommended. I've found that running these types of tests can be very slow. (hence the Goal #2).
Unfortunately, if you have a fair amount of code that relies on other code using static methods, you are at mercy of your own debt. There are some techniques using call_user_func(https://medium.com/#nihon_rafy/how-to-mock-static-methods-for-unit-tests-in-php-18b2a11458d0) and forward_static_call_array() (http://miljar.github.io/blog/2014/01/29/phpunit-testing-static-calls/), but I find myself having difficulty following this code.
I want to provide an alternative dynamic option, similar to the above.
class LegacyClass {
public static function staticMethod($a, $b, $c) {
return QueryBuilder::where($a, $b, $c)->getAll();
}
}
class ClassToTest {
public function test($a, $b, $c) {
return LegacyClass::staticMethod($a+1, $b+2, $c+3);
}
changes to this =>
class LegacyClass {
public static function staticMethod($a, $b, $c) {
return QueryBuilder::where($a, $b, $c)->getAll();
}
}
class ClassToTest{
// #var string fully qualified class name
private $legacyClass = LegacyClass::class;
public function test($a, $b, $c) {
return {$this->legacyClass}::staticMethod($a+1, $b+2, $c+3);
}
Now, with the above, we can mock the LegacyClass, get the class name of that mock, and use Reflection to set the private $legacyClass variable.
With that, my questions:
Which of the options above present the most maintainable solution?
Are there any better alternatives that meet the stated goals? (If so, I can append)
Thank you for your input!

Answer 1

A solution that I have been going back to very often is creating a "man-in-the-middle"-class. I use this for static function calls but also for cases where a new Object(); was created in the middle of the code.
In essence you are simply moving the problem somewhere else which might not look like a good solution but you make your ClassToTest easily testable by moving one line away.
So in short; I would make a new class (StaticFunctionCallerClass). This class would have one function that has one line.
class StaticFunctionCallerClass {
public function test($a, $b, $c) {
return LegacyClass::staticMethod($a+1, $b+2, $c+3);
}
Now you can instantiate this class in your ClassToTest (and therefore mock it in the test). So you can test all the logic around it and even test that your new StaticFunctionCallerClass is also called with the right information.
The drawback here is that it leaves your new StaticFunctionCallerClass with the line of hard to test code. You could call this class in your LegacyClassTest to test if the call is done correctly though, which is maybe not a very clean option but it does get the job done.