<?phpnamespace GuzzleHttp\Handler;use GuzzleHttp\Exception\RequestException;use GuzzleHttp\HandlerStack;use GuzzleHttp\Promise as P;use GuzzleHttp\Promise\PromiseInterface;use GuzzleHttp\TransferStats;use GuzzleHttp\Utils;use Psr\Http\Message\RequestInterface;use Psr\Http\Message\ResponseInterface;use Psr\Http\Message\StreamInterface;/** * Handler that returns responses or throw exceptions from a queue. * * @final */class MockHandler implements \Countable{    /**     * @var array     */    private $queue = [];    /**     * @var RequestInterface|null     */    private $lastRequest;    /**     * @var array     */    private $lastOptions = [];    /**     * @var callable|null     */    private $onFulfilled;    /**     * @var callable|null     */    private $onRejected;    /**     * Creates a new MockHandler that uses the default handler stack list of     * middlewares.     *     * @param array|null    $queue       Array of responses, callables, or exceptions.     * @param callable|null $onFulfilled Callback to invoke when the return value is fulfilled.     * @param callable|null $onRejected  Callback to invoke when the return value is rejected.     */    public static function createWithMiddleware(array $queue = null, callable $onFulfilled = null, callable $onRejected = null): HandlerStack

			Why this impedes flexibility

Static methods
Summary of issues
Tight Coupling
Hidden dependencies
Global state (if also using static variables)
Tight Coupling
Use of static methods always reduces flexibility by introducing tight coupling[1]. A static method tightly couples the calling code to the specific class the method exists in.

 
function totalAbs(double value, double value2) {
    return abs(value) + abs(value2);
}

Here, the method totalAbs has a dependency on the Math class and the .abs() method will always be called. Although for testing purposes this may not be a problem, the coupling reduces flexibility because the total method can only work with doubles/integers, as that's all the Math.abs() function can use. Although type coercion will allow the use of any primitive numeric type, these types have limitations. It's impossible to use another class such as BigInteger or a class for dealing with greater precision decimals or even alternative numbering systems such as Roman numerals.
The totalAbs function takes two doubles and converts them to their absolute values before adding them. This is inflexible because it only works with doubles. It's tied to doubles because that's what the Math.abs() static method requires. If, instead, using OOP an interface was created to handle any number that had this method:

 interface Numeric {
    public function abs(): Numeric;
}

It would then be possible to rewrite the totalAbs method to work with any kind of number:

 function totalAbs(Numeric value, Numeric value): Numeric {
    return value.abs() + value2.abs();
}


By removing the static method and using an instance method in its place the totalAbs method is now agnostic about the type of number it is dealing with. It could be called with any of the following (assuming they implement the Numeric interface)

 
totalAbs(new Integer(4), new Integer(-53));

totalAbs(new Double(34.4), new Integer(-2));

totalAbs(new BigInteger('123445454564765739878989343225778'), new Integer(2343));

totalAbs(new RomanNumeral('VII'), new RomanNumeral('CXV'));


Making the method reusable in a way that it wasn't when static methods were being used. By changing the static methods to instance methods, flexibility has been enhanced as the method can be used with any numeric type, not just numeric types that are supported by the Math.abs() method.
Broken encapsulation
Static methods also break encapsulation. Encapsulation is defined by Rogers[2] as:
the bundling of data with the methods that operate on that data
By passing the numeric value into the abs method, the data being operated on is being separated from the methods that operate on it, breaking encapsulation. Instead using num.abs() the data is encapsulated in the num instance and its type is not visible or relevant to the outside world. abs() will work on the data and work regardless of num's type, providing it implements the abs method.
This is a simple example, but applies to all static methods. Use of polymorphic instance methods that work on encapsulated data will always be more flexible than static method calls which can only ever deal with specific pre-defined types.
Further reading
What is tight coupling?
Why Static is Bad and How to Avoid It
Static Methods Will Shock You
Flaw: Brittle Global State & Singletons
Static Methods are Death to Testability
Exceptions
The only exception to this rule is when a static method is used for object creation in place of the new keyword[3]. This is because the new keyword is already a static call. However, even here a non-static factory is often preferable for testing purposes[4][5].
References
Popov, N. (2014) Don't be STUPID: GRASP SOLID!  [online]. Available from: https://nikic.github.io/2011/12/27/Dont-be-STUPID-GRASP-SOLID.html 
Rogers, P. (2001) Encapsulation is not information hiding [online]. Available from: http://www.javaworld.com/article/2075271/core-java/encapsulation-is-not-information-hiding.html 
Sonmez, J. (2010)  Static Methods Will Shock You  [online]. Available from: http://simpleprogrammer.com/2010/01/29/static-methods-will-shock-you/ 
Hevery, M. (2008) Static Methods are Death to Testability [online]. Available from: http://misko.hevery.com/2008/12/15/static-methods-are-death-to-testability/ 
Butler, T. (2013) Are Static Methods/Variables bad practice? [online]. Available from: https://r.je/static-methods-bad-practice.html 
    {        return HandlerStack::create(new self($queue, $onFulfilled, $onRejected));    }    /**     * The passed in value must be an array of     * {@see \Psr\Http\Message\ResponseInterface} objects, Exceptions,     * callables, or Promises.     *     * @param array<int, mixed>|null $queue       The parameters to be passed to the append function, as an indexed array.     * @param callable|null          $onFulfilled Callback to invoke when the return value is fulfilled.     * @param callable|null          $onRejected  Callback to invoke when the return value is rejected.     */    public function __construct(array $queue = null, callable $onFulfilled = null, callable $onRejected = null)    {        $this->onFulfilled = $onFulfilled;        $this->onRejected = $onRejected;        if ($queue) {            // array_values included for BC            $this->append(...array_values($queue));        }    }    public function __invoke(RequestInterface $request, array $options): PromiseInterface    {        if (!$this->queue) {            throw new \OutOfBoundsException('Mock queue is empty');        }        if (isset($options['delay']) && \is_numeric($options['delay'])) {            \usleep((int) $options['delay'] * 1000);        }        $this->lastRequest = $request;        $this->lastOptions = $options;        $response = \array_shift($this->queue);        if (isset($options['on_headers'])) {            if (!\is_callable($options['on_headers'])) {                throw new \InvalidArgumentException('on_headers must be callable');            }            try {                $options['on_headers']($response);            } catch (\Exception $e) {                $msg = 'An error was encountered during the on_headers event';                $response = new RequestException($msg, $request, $response, $e);            }        }        if (\is_callable($response)) {            $response = $response($request, $options);        }        $response = $response instanceof \Throwable            ? P\Create::rejectionFor($response)            : P\Create::promiseFor($response);        return $response->then(            function (?ResponseInterface $value) use ($request, $options) {                $this->invokeStats($request, $options, $value);                if ($this->onFulfilled) {                    ($this->onFulfilled)($value);                }                if ($value !== null && isset($options['sink'])) {                    $contents = (string) $value->getBody();                    $sink = $options['sink'];                    if (\is_resource($sink)) {                        \fwrite($sink, $contents);                    } elseif (\is_string($sink)) {                        \file_put_contents($sink, $contents);                    } elseif ($sink instanceof StreamInterface) {                        $sink->write($contents);                    }                }                return $value;            },            function ($reason) use ($request, $options) {                $this->invokeStats($request, $options, null, $reason);                if ($this->onRejected) {                    ($this->onRejected)($reason);                }                return P\Create::rejectionFor($reason);            }        );    }    /**     * Adds one or more variadic requests, exceptions, callables, or promises     * to the queue.     *     * @param mixed ...$values     */    public function append(...$values): void    {        foreach ($values as $value) {            if ($value instanceof ResponseInterface                || $value instanceof \Throwable                || $value instanceof PromiseInterface                || \is_callable($value)            ) {                $this->queue[] = $value;            } else {                throw new \TypeError('Expected a Response, Promise, Throwable or callable. Found ' . Utils::describeType($value));            }        }    }    /**     * Get the last received request.     */    public function getLastRequest(): ?RequestInterface    {        return $this->lastRequest;    }    /**     * Get the last received request options.     */    public function getLastOptions(): array    {        return $this->lastOptions;    }    /**     * Returns the number of remaining items in the queue.     */    public function count(): int    {        return \count($this->queue);    }    public function reset(): void    {        $this->queue = [];    }    /**     * @param mixed $reason Promise or reason.     */    private function invokeStats(        RequestInterface $request,        array $options,        ResponseInterface $response = null,        $reason = null    ): void {        if (isset($options['on_stats'])) {            $transferTime = $options['transfer_time'] ?? 0;            $stats = new TransferStats($request, $response, $transferTime, $reason);            ($options['on_stats'])($stats);        }    }}