PHPUnit: Verificación de esa matriz tiene una llave con valor dado

Question

Dada la siguiente clase:

<?php
class Example {
    private $Other;

    public function __construct ($Other)
    {
        $this->Other = $Other;
    }

    public function query ()
    {   
        $params = array(
            'key1' => 'Value 1'
            , 'key2' => 'Value 2'
        );

        $this->Other->post($params);
    }
}

Y este caso de prueba:

<?php
require_once 'Example.php';
require_once 'PHPUnit/Framework.php';

class ExampleTest extends PHPUnit_Framework_TestCase {

    public function test_query_key1_value ()
    {   
        $Mock = $this->getMock('Other', array('post'));

        $Mock->expects($this->once())
              ->method('post')
              ->with(YOUR_IDEA_HERE);

        $Example = new Example($Mock);
        $Example->query();
    }

¿Cómo verifico que $params (que es un array) y se pasa a $Other->post() contiene una clave denominada 'key1' que tiene un valor de 'Valor 1'?

No quiero para verificar toda la gama - esto es sólo un código de ejemplo, en el código real de la matriz pasada tiene mucho más valores, quiero verificar sólo un único par clave / valor en allí

No es $this->arrayHasKey('keyname') que puedo usar para verificar que existe la clave.

Hay también $this->contains('Value 1'), que puede ser utilizado para verificar que la matriz tiene este valor.

Podría incluso combinar los dos con $this->logicalAnd. Pero esto, por supuesto, no da el resultado deseado.

Hasta ahora han estado utilizando returnCallback, capturando los $ params enteros y luego haciendo afirma en eso, pero no es tal vez otra manera de hacer lo que quiero?

Answer 1

Terminé la creación de mi propia clase de restricción, basado en el atributo de un solo

<?php
class Test_Constraint_ArrayHas extends PHPUnit_Framework_Constraint
{
    protected $arrayKey;

    protected $constraint;

    protected $value;

    /**
     * @param PHPUnit_Framework_Constraint $constraint
     * @param string                       $arrayKey
     */
    public function __construct(PHPUnit_Framework_Constraint $constraint, $arrayKey)
    {
        $this->constraint  = $constraint;
        $this->arrayKey    = $arrayKey;
    }


    /**
     * Evaluates the constraint for parameter $other. Returns TRUE if the
     * constraint is met, FALSE otherwise.
     *
     * @param mixed $other Value or object to evaluate.
     * @return bool
     */
    public function evaluate($other)
    {
        if (!array_key_exists($this->arrayKey, $other)) {
            return false;
        }

        $this->value = $other[$this->arrayKey];

        return $this->constraint->evaluate($other[$this->arrayKey]);
    }

    /**
     * @param   mixed   $other The value passed to evaluate() which failed the
     *                         constraint check.
     * @param   string  $description A string with extra description of what was
     *                               going on while the evaluation failed.
     * @param   boolean $not Flag to indicate negation.
     * @throws  PHPUnit_Framework_ExpectationFailedException
     */
    public function fail($other, $description, $not = FALSE)
    {
        parent::fail($other[$this->arrayKey], $description, $not);
    }


    /**
     * Returns a string representation of the constraint.
     *
     * @return string
     */
    public function toString ()
    {
        return 'the value of key "' . $this->arrayKey . '"(' . $this->value . ') ' .  $this->constraint->toString();
    }


    /**
     * Counts the number of constraint elements.
     *
     * @return integer
     */
    public function count ()
    {
        return count($this->constraint) + 1;
    }


    protected function customFailureDescription ($other, $description, $not)
    {
        return sprintf('Failed asserting that %s.', $this->toString());
    }

Puede ser utilizado como esto:

 ... ->with(new Test_Constraint_ArrayHas($this->equalTo($value), $key));

Answer 2

existe El método $this->arrayHasKey('keyname'); pero su nombre es assertArrayHasKey:

// In your PHPUnit test method
$hi = array(
    'fr' => 'Bonjour',
    'en' => 'Hello'
);

$this->assertArrayHasKey('en', $hi);    // Succeeds
$this->assertArrayHasKey('de', $hi);    // Fails

Answer 3

En lugar de crear una clase de restricción reutilizable, yo era capaz de afirmar el valor de una clave matriz mediante la restricción de devolución de llamada existente en PHPUnit. En mi caso de uso, que necesitaba para comprobar un valor de matriz en el segundo argumento a un método burlado ( MongoCollection :: ensureIndex () , si alguien tiene curiosidad). Esto es lo que ocurrió:

$mockedObject->expects($this->once())
    ->method('mockedMethod')
    ->with($this->anything(), $this->callback(function($o) {
        return isset($o['timeout']) && $o['timeout'] === 10000;
    }));

El limitación de devolución de llamada espera un exigible en su constructor, y simplemente se invoca durante la evaluación. La afirmación de pasa o falla en función de si los desembolsadas rendimientos verdadero o falso.

Para un proyecto grande, sin duda me recomiendo crear un reutilizable restricción (como en la solución anterior) o solicitando a PR # 312 que se fusionó con PHPUnit, pero esto hizo el truco para una necesidad de una sola vez. Es fácil ver cómo la restricción de devolución de llamada podría ser útil para las aseveraciones más complicados, también.

Answer 4

En el caso de que deseen hacer algunas pruebas complejas en el parámetro, y también tienen mensajes y comparaciones útiles, siempre existe la opción de colocar las afirmaciones dentro de la devolución de llamada.

por ejemplo.

$clientMock->expects($this->once())->method('post')->with($this->callback(function($input) {
    $this->assertNotEmpty($input['txn_id']);
    unset($input['txn_id']);
    $this->assertEquals($input, array(
        //...
    ));
    return true;
}));

Tenga en cuenta que la devolución de llamada devuelve verdadero. De lo contrario, siempre sería un fracaso.

Answer 5

Lo sentimos, no soy un orador Inglés.

Creo que se puede probar si existe una clave en la matriz con la función array_key_exists, y se puede probar si el valor existe con array_search

Por ejemplo:

function checkKeyAndValueExists($key,$value,$arr){
    return array_key_exists($key, $arr) && array_search($value,$arr)!==false;
}

Utilice !== porque array_search devolver la llave de ese valor si existe y puede ser 0.