Cómo hacer una prueba unitaria de los rasgos de PHP

Quiero saber si hay una solución sobre cómo probar un rasgo de PHP.

Sé que podemos probar una clase que usa el rasgo, pero me preguntaba si hay mejores enfoques.

Gracias por cualquier consejo de antemano 🙂

EDITAR

Una alternativa es usar el Trait en la clase de prueba en sí, como lo demostraré a continuación.

Pero No estoy tan interesado en este enfoque ya que no hay garantía de que no haya nombres de métodos similares entre el rasgo, la clase y también el PHPUnit_Framework_TestCase (en este ejemplo):

Aquí hay un rasgo de ejemplo:

trait IndexableTrait
{
    /** @var int */
    private $index;

    /**
     * @param $index
     * @return $this
     * @throw \InvalidArgumentException
     */
    public function setIndex($index)
    {
        if (false === filter_var($index, FILTER_VALIDATE_INT)) {
            throw new \InvalidArgumentException('$index must be integer.');
        }

        $this->index = $index;

        return $this;
    }

    /**
     * @return int|null
     */
    public function getIndex()
    {
        return $this->index;
    }
}

y su prueba:

class TheAboveTraitTest extends \PHPUnit_Framework_TestCase
{
    use TheAboveTrait;

    public function test_indexSetterAndGetter()
    {
        $this->setIndex(123);
        $this->assertEquals(123, $this->getIndex());
    }

    public function test_indexIntValidation()
    {
        $this->setExpectedException(\Exception::class, '$index must be integer.');
        $this->setIndex('bad index');
    }
}

Puede probar un rasgo utilizando métodos concretos similares a los de una clase abstracta.

PHPUnit tiene un método getMockForTrait que devolverá un objeto que usa el rasgo. Entonces puedes probar las funciones de rasgos.

Aquí está el ejemplo de la documentación:

<?php
trait AbstractTrait
{
    public function concreteMethod()
    {
        return $this->abstractMethod();
    }

    public abstract function abstractMethod();
}

class TraitClassTest extends PHPUnit_Framework_TestCase
{
    public function testConcreteMethod()
    {
        $mock = $this->getMockForTrait('AbstractTrait');

        $mock->expects($this->any())
             ->method('abstractMethod')
             ->will($this->returnValue(TRUE));

        $this->assertTrue($mock->concreteMethod());
    }
}
?>

También puedes usar getObjectForTrait luego afirme el resultado real si lo desea.

class YourTraitTest extends TestCase
{
    public function testGetQueueConfigFactoryWillCreateConfig()
    {
        $obj = $this->getObjectForTrait(YourTrait::class);

        $config = $obj->getQueueConfigFactory();

        $this->assertInstanceOf(QueueConfigFactory::class, $config);
    }

    public function testGetQueueServiceWithoutInstanceWillCreateConfig()
    {
        $obj = $this->getObjectForTrait(YourTrait::class);

        $service = $obj->getQueueService();

        $this->assertInstanceOf(QueueService::class, $service);
    }
}

Desde PHP 7 ahora podemos usar clases anónimas…

$class = new class {
    use TheTraitToTest;
};

// We now have everything available to test using $class