¿Cómo puedo probar el código no inyectable?

Hay algunas posibilidades, cómo simular métodos de static en PHP, la mejor solución que he usado es la biblioteca AspectMock , que se puede extraer a través del compositor (la forma de simular métodos estáticos es bastante comprensible en la documentación).

Sin embargo, es una solución de último momento para un problema que debería solucionarse de otra manera.

Si aún desea realizar una prueba unitaria de la capa responsable de transformar las consultas, hay una forma bastante rápida de hacerlo.

Supongo que en este momento el método validate es parte de alguna clase, la solución muy rápida, que no requiere que transformes todas tus llamadas estáticas a llamadas de instancia, es crear clases que actúen como proxies para tus métodos estáticos e inyecte estos proxies en las clases que anteriormente utilizaban los métodos estáticos.

class EmailAlertToSearchAdapterProxy
{
    public function adapt($value)
    {
        return EmailAlertToSearchAdapter::adapt($value);
    }
}

class SearcherFactoryProxy
{
    public function getSearchDirector(array $keywords)
    {
        return SearcherFactory::getSearchDirector($keywords);
    }
}

class ClassWithValidateMethod
{
    private $emailProxy;
    private $searcherProxy;

    public function __construct(
        EmailAlertToSearchAdapterProxy $emailProxy,
        SearcherFactoryProxy $searcherProxy
    )
    {
        $this->emailProxy = $emailProxy;
        $this->searcherProxy = $searcherProxy;
    }

    public function validate($value, Constraint $constraint)
    {
        $searchEntity = $this->emailProxy->adapt($value);

        $queryBuilder = $this->searcherProxy->getSearchDirector($searchEntity->getKeywords());
        $adapter = new SearchEntityToQueryAdapter($queryBuilder, $searchEntity);
        $query = $adapter->setupBuilder()->build();

        $totalCount = $this->advertType->count($query);

        if ($totalCount >= self::MAXIMUM_MATCHING_ADS) {
            $this->context->addViolation(
                $constraint->message
            );
        }
    }
}

Primero, sugeriría dividir esto en métodos separados:

public function validate($value, Constraint $constraint)
{
    $totalCount = QueryTotal($value);
    ShowMessageWhenTotalExceedsMaximum($totalCount,$constraint);
}

private function QueryTotal($value)
{
    $searchEntity = EmailAlertToSearchAdapter::adapt($value);

    $queryBuilder = SearcherFactory::getSearchDirector($searchEntity->getKeywords());
    $adapter = new SearchEntityToQueryAdapter($queryBuilder, $searchEntity);
    $query = $adapter->setupBuilder()->build();

    return $this->advertType->count($query);
}

private function ShowMessageWhenTotalExceedsMaximum($totalCount,$constraint)
{
    if ($totalCount >= self::MAXIMUM_MATCHING_ADS) {
        $this->context->addViolation(
            $constraint->message
        );
    }
}

Esto te deja en una situación en la que puedes considerar hacer que esos dos nuevos métodos sean públicos y unit unit test QueryTotal y ShowMessageWhenTotalExceedsMaximum individualmente. Una opción viable aquí es en realidad no a la prueba unitaria QueryTotal , ya que esencialmente solo probarías en ElasticSearch. Escribir una prueba de unidad para ShowMessageWhenTotalExceedsMaximum debería ser fácil y tiene mucho más sentido, ya que en realidad probaría la lógica de su negocio.

Sin embargo, si prefiere probar "validar" directamente, considere pasar la función de consulta como un parámetro a "validar" (con un valor predeterminado de $this->QueryTotal ), esto le permitirá simular la consulta función. No estoy seguro de si entendí correctamente la sintaxis de PHP, por lo que en caso de que no lo hiciera, lea esto como "Pseudo código":

public function validate($value, Constraint $constraint, $queryFunc=$this->QueryTotal)
{
    $totalCount =  $queryFunc($value);
    ShowMessageWhenTotalExceedsMaximum($totalCount,$constraint);
}