Możesz przetestować prywatne metody ale nie można symulować (naśladować) działania tych metod.

Ponadto, odbicie nie pozwala na konwersję metody prywatnej na metodę chronioną lub publiczną. setAccessible pozwala tylko na wywołanie oryginalnej metody.

Alternatywnie możesz użyć runkit do zmiany nazw metod prywatnych i dodania "nowej implementacji". Jednak funkcje te są eksperymentalne i ich użycie nie jest polecam.

Możesz użyć reflection i setAccessible() w Twoich testach, aby umożliwić Ci ustawienie wewnętrznego stanu obiektu w taki sposób, że zwróci to, co chcesz od metody prywatnej. Musisz być na PHP 5.3.2.

$fixture = new MyClass(...);
$reflector = new ReflectionProperty('MyClass', 'myPrivateProperty');
$reflector->setAccessible(true);
$reflector->setValue($fixture, 'value');
// test $fixture ...

Mock of protected method, so if you can convert C to protected then this code will help.

 $mock = $this->getMockBuilder('A')
                  ->disableOriginalConstructor()
                  ->setMethods(array('C'))
                  ->getMock();

    $response = $mock->B();

Zakładając, że musisz przetestować $myClass- > privateMethodX ($arg1, $arg2), możesz to zrobić z odbiciem:

$class = new ReflectionClass ($myClass);
$method = $class->getMethod ('privateMethodX');
$method->setAccessible(true);
$output = $method->invoke ($myClass, $arg1, $arg2);

Oto odmiana innych odpowiedzi, które mogą być użyte do wykonania takich połączeń w jednej linii:

public function callPrivateMethod($object, $methodName)
{
    $reflectionClass = new \ReflectionClass($object);
    $reflectionMethod = $reflectionClass->getMethod($methodName);
    $reflectionMethod->setAccessible(true);

    $params = array_slice(func_get_args(), 2); //get all the parameters after $methodName
    return $reflectionMethod->invokeArgs($object, $params);
}

Wymyśliłem tę klasę ogólnego przeznaczenia dla mojej sprawy:

/**
 * @author Torge Kummerow
 */
class Liberator {
    private $originalObject;
    private $class;

    public function __construct($originalObject) {
        $this->originalObject = $originalObject;
        $this->class = new ReflectionClass($originalObject);
    }

    public function __get($name) {
        $property = $this->class->getProperty($name);
        $property->setAccessible(true);
        return $property->getValue($this->originalObject);
    }

    public function __set($name, $value) {
        $property = $this->class->getProperty($name);            
        $property->setAccessible(true);
        $property->setValue($this->originalObject, $value);
    }

    public function __call($name, $args) {
        $method = $this->class->getMethod($name);
        $method->setAccessible(true);
        return $method->invokeArgs($this->originalObject, $args);
    }
}

Z tą klasą możesz teraz łatwo i przejrzyście wyzwalać wszystkie prywatne funkcje / pola na dowolnym obiekcie.

$myObject = new Liberator(new MyObject());
/* @var $myObject MyObject */  //Usefull for code completion in some IDEs

//Writing to a private field
$myObject->somePrivateField = "testData";

//Reading a private field
echo $myObject->somePrivateField;

//calling a private function
$result = $myObject->somePrivateFunction($arg1, $arg2);

Jeśli wydajność jest ważna, można ją poprawić poprzez buforowanie właściwości / metod wywołanych w klasie Liberator.

Jedną z opcji byłoby c() protected zamiast private, a następnie podklasuj i nadpisuj c(). Następnie przetestuj swoją podklasę. Inną opcją byłoby przekształcenie c() do innej klasy, którą można wprowadzić do A (nazywa się to iniekcją zależności). Następnie wstrzyknij instancję testową z przykładową implementacją c() W teście jednostkowym.

Alternatywnym rozwiązaniem jest zmiana metody prywatnej na chronioną, a następnie mock.

$myMockObject = $this->getMockBuilder('MyMockClass')
        ->setMethods(array('__construct'))
        ->setConstructorArgs(array("someValue", 5))
        ->setMethods(array('myProtectedMethod'))
        ->getMock();

$response = $myMockObject->myPublicMethod();

Gdzie myPublicMethod wywołuje myProtectedMethod. Niestety nie możemy tego zrobić z prywatnymi metodami, ponieważ setMethods nie możemy znaleźć prywatnej metody, gdzie można znaleźć chronioną metodę

Możesz używać anonimowych klas używając PHP 7.

$mock = new class Concrete {
    private function bob():void
    {
    }
};

W poprzednich wersjach PHP można utworzyć klasę testową rozszerzającą klasę bazową.