readthedocs - phpunit tutorial

PHPUnit: Verificando que la matriz tiene una clave con un 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 testcase:

<?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 una matriz) y se pasa a $Other->post() contiene una clave llamada ''key1'' que tiene un valor de ''Value 1''?

No quiero verificar toda la matriz. Esto es solo un código de muestra. En el código real, la matriz pasada tiene muchos más valores, quiero verificar solo un único par de clave / valor allí.

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

También hay $this->contains(''Value 1'') , que puede usarse para verificar que la matriz tiene este valor.

Incluso podría combinar esos dos con $this->logicalAnd . Pero esto, por supuesto, no da el resultado deseado.

Hasta ahora he estado usando returnCallback, capturando los $ params completos y luego haciendo afirmaciones sobre eso, pero ¿hay tal vez otra forma de hacer lo que quiero?

Answer 1

El $this->arrayHasKey(''keyname''); método existe 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 2

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

p.ej

$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 fallaría.

Answer 3

En lugar de crear una clase de restricción reutilizable, pude afirmar el valor de una clave de matriz utilizando la restricción de devolución de llamada existente en PHPUnit. En mi caso de uso, necesitaba verificar un valor de matriz en el segundo argumento de un método MongoCollection::ensureIndex() ( MongoCollection::ensureIndex() , si alguien tiene curiosidad). Esto es lo que se me ocurrió:

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

La restricción de devolución de llamada espera un invocable en su constructor, y simplemente la invoca durante la evaluación. La afirmación pasa o falla en función de si la llamada devuelve verdadero o falso.

Para un proyecto grande, sin duda recomendaría crear una restricción reutilizable (como en la solución anterior) o solicitar que PR # 312 se fusione en PHPUnit, pero esto funcionó para una sola necesidad. Es fácil ver cómo la restricción de devolución de llamada también podría ser útil para afirmaciones más complicadas.

Answer 4

Lo siento, no soy un hablante de inglés.

Creo que puedes probar si existe una clave en la matriz con la función array_key_exists, y puedes 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;
}

Use !== porque array_search devuelve la clave de ese valor si existe y puede ser 0.

Answer 5

Terminé creando mi propia clase de restricción, basada en el atributo uno

<?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());
    }

Se puede usar así:

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