Respuestas de prueba

La clase TestResponse proporciona una serie de funciones útiles para analizar y probar respuestas. de sus casos de prueba. Por lo general, se le proporcionará una Respuesta de prueba como resultado de su Pruebas del controlador o Pruebas de funciones HTTP , pero siempre puedes cree el suyo propio directamente usando cualquier ResponseInterface:

$result = new \Higgs\Test\TestResponse($response);
$result->assertOK();

Probando la respuesta

Ya sea que haya recibido una Respuesta de prueba como resultado de sus pruebas o que haya creado una usted mismo, Hay una serie de afirmaciones nuevas que puede utilizar en sus pruebas.

Accediendo a Solicitud/Respuesta

pedido()

Puede acceder directamente al objeto Solicitud, si se configuró durante la prueba:

$request = $results->request();

respuesta()

Esto le permite acceso directo al objeto de respuesta:

$response = $results->response();

Comprobación del estado de la respuesta

está bien()

Devuelve un valor booleano verdadero/falso en función de si la respuesta se percibe como «correcta». Esto está determinado principalmente por un código de estado de respuesta en el 200 o 300. Un cuerpo vacío no se considera válido, a menos que se trate de redirecciones.

if ($result->isOK()) {
    // ...
}

afirmarOK()

Esta afirmación simplemente utiliza el método isOK() para probar una respuesta. assertNotOK() es lo inverso de esta afirmación.

$result->assertOK();

esRedirect()

Devuelve un valor booleano verdadero/falso en función de si la respuesta es una respuesta redirigida.

if ($result->isRedirect()) {
    // ...
}

afirmarRedirect()

Afirma que la respuesta es una instancia de RedirectResponse. assertNotRedirect() es lo inverso de esta afirmación.

$result->assertRedirect();

afirmarRedirectTo()

Afirma que la respuesta es una instancia de RedirectResponse y el destino coincide con el uri proporcionado.

$result->assertRedirectTo('foo/bar');

getRedirectUrl()

Devuelve la URL establecida para RedirectResponse, o nula en caso de error.

$url = $result->getRedirectUrl();
$this->assertEquals(site_url('foo/bar'), $url);

afirmarEstado(int $código)

Afirma que el código de estado HTTP devuelto coincide con $code.

$result->assertStatus(403);

Afirmaciones de sesión

afirmarSessionHas(cadena $clave, $valor = nulo)

Afirma que existe un valor en la sesión resultante. Si se pasa $value, también afirmará que el valor de la variable coincide con lo especificado.

$result->assertSessionHas('logged_in', 123);

afirmarSessionMissing(cadena $clave)

Afirma que la sesión resultante no incluye la clave $ especificada.

$result->assertSessionMissing('logged_in');

Afirmaciones de encabezado

afirmarHeader(cadena $clave, $valor = nulo)

Afirma que existe un encabezado denominado $key en la respuesta. Si $value no está vacío, también afirmará que los valores coinciden.

$result->assertHeader('Content-Type', 'text/html');

afirmarHeaderMissing(cadena $clave)

Afirma que no existe un nombre de encabezado $key en la respuesta.

$result->assertHeader('Accepts');

Afirmaciones de cookies

afirmarCookie(cadena $clave, $valor = nulo, cadena $prefijo = “”)

Afirma que existe una cookie denominada $key en la respuesta. Si $value no está vacío, también afirmará que los valores coinciden. Puede configurar el prefijo de cookie, si es necesario, pasándolo como tercer parámetro.

$result->assertCookie('foo', 'bar');

afirmarCookieMissing(cadena $clave)

Afirma que una cookie denominada $key no existe en la respuesta.

$result->assertCookieMissing('HIGGS_session');

afirmarCookieExpired(cadena $clave, cadena $prefijo = “”)

Afirma que existe una cookie llamada $key, pero ha caducado. Puede configurar el prefijo de cookie, si es necesario, pasándolo como segundo parámetro.

$result->assertCookieExpired('foo');

Ayudantes DOM

La respuesta que recibe contiene una serie de métodos auxiliares para inspeccionar la salida HTML dentro de la respuesta. Estos son útiles para usar dentro de afirmaciones en sus pruebas.

ver()

Devuelve un valor booleano verdadero/falso en función de si el texto de la página existe o no. por sí mismo, o más específicamente dentro de una etiqueta, según lo especificado por tipo, clase o identificación:

// Check that "Hello World" is on the page
if ($results->see('Hello World')) {
    // ...
}

// Check that "Hello World" is within an h1 tag
if ($results->see('Hello World', 'h1')) {
    // ...
}

// Check that "Hello World" is within an element with the "notice" class
if ($results->see('Hello World', '.notice')) {
    // ...
}

// Check that "Hello World" is within an element with id of "title"
if ($results->see('Hello World', '#title')) {
    // ...
}

El método dontSee() es exactamente lo contrario:

// Checks that "Hello World" does NOT exist on the page
if ($results->dontSee('Hello World')) {
    // ...
}

// Checks that "Hellow World" does NOT exist within any h1 tag
if ($results->dontSee('Hello World', 'h1')) {
    // ...
}

verElemento()

Los seeElement() y dontSeeElement() son muy similares a los métodos anteriores, pero no te fijes en el valores de los elementos. En cambio, simplemente verifican que los elementos existan en la página:

// Check that an element with class 'notice' exists
if ($results->seeElement('.notice')) {
    // ...
}

// Check that an element with id 'title' exists
if ($results->seeElement('#title')) {
    // ...
}

// Verify that an element with id 'title' does NOT exist
if ($results->dontSeeElement('#title')) {
    // ...
}

verEnlace()

Puede utilizar seeLink() para asegurarse de que aparezca un enlace en la página con el texto especificado:

// Check that a link exists with 'Upgrade Account' as the text::
if ($results->seeLink('Upgrade Account')) {
    // ...
}

// Check that a link exists with 'Upgrade Account' as the text, AND a class of 'upsell'
if ($results->seeLink('Upgrade Account', '.upsell')) {
    // ...
}

ver en el campo()

El método seeInField() comprueba si existe alguna etiqueta de entrada con el nombre y el valor:

// Check that an input exists named 'user' with the value 'John Snow'
if ($results->seeInField('user', 'John Snow')) {
    // ...
}

// Check a multi-dimensional input
if ($results->seeInField('user[name]', 'John Snow')) {
    // ...
}

verCheckboxIsChecked()

Finalmente, puedes verificar si existe una casilla de verificación y está marcada con el método seeCheckboxIsChecked():

// Check if checkbox is checked with class of 'foo'
if ($results->seeCheckboxIsChecked('.foo')) {
    // ...
}

// Check if checkbox with id of 'bar' is checked
if ($results->seeCheckboxIsChecked('#bar')) {
    // ...
}

Afirmaciones DOM

Puede realizar pruebas para ver si existen elementos/texto/etc. específicos en el cuerpo de la respuesta con lo siguiente afirmaciones.

afirmarVer(cadena $búsqueda = nulo, cadena $elemento = nulo)

Afirma que el texto/HTML está en la página, ya sea por sí mismo o, más específicamente, dentro una etiqueta, según lo especificado por tipo, clase o identificación:

// Verify that "Hello World" is on the page
$result->assertSee('Hello World');

// Verify that "Hello World" is within an h1 tag
$result->assertSee('Hello World', 'h1');

// Verify that "Hello World" is within an element with the "notice" class
$result->assertSee('Hello World', '.notice');

// Verify that "Hello World" is within an element with id of "title"
$result->assertSee('Hello World', '#title');

afirmarDontSee(cadena $búsqueda = nulo, cadena $elemento = nulo)

Afirma exactamente lo contrario del método assertSee():

// Verify that "Hello World" does NOT exist on the page
$results->assertDontSee('Hello World');

// Verify that "Hello World" does NOT exist within any h1 tag
$results->assertDontSee('Hello World', 'h1');

afirmarVerElemento(cadena $búsqueda)

Similar a assertSee(), sin embargo, esto solo verifica si hay un elemento existente. No busca texto específico:

// Verify that an element with class 'notice' exists
$results->assertSeeElement('.notice');

// Verify that an element with id 'title' exists
$results->assertSeeElement('#title');

afirmarDontSeeElement(cadena $búsqueda)

Similar a assertSee(), sin embargo, esto solo busca un elemento existente que falta. No comprueba texto específico:

// Verify that an element with id 'title' does NOT exist
$results->assertDontSeeElement('#title');

afirmarVerEnlace(cadena $texto, cadena $detalles = nulo) ————————————————– -

Afirma que se encuentra una etiqueta de anclaje con $text coincidente como cuerpo de la etiqueta:

// Verify that a link exists with 'Upgrade Account' as the text::
$results->assertSeeLink('Upgrade Account');

// Verify that a link exists with 'Upgrade Account' as the text, AND a class of 'upsell'
$results->assertSeeLink('Upgrade Account', '.upsell');

afirmarSeeInField(cadena $campo, cadena $valor = nulo)

Afirma que existe una etiqueta de entrada con el nombre y valor:

// Verify that an input exists named 'user' with the value 'John Snow'
$results->assertSeeInField('user', 'John Snow');

// Verify a multi-dimensional input
$results->assertSeeInField('user[name]', 'John Snow');

Trabajar con JSON

Las respuestas con frecuencia contendrán respuestas JSON, especialmente cuando se trabaja con métodos API. Los siguientes métodos puede ayudar a probar las respuestas.

obtener JSON()

Este método devolverá el cuerpo de la respuesta como una cadena JSON:

/*
 * Response body is this:
 * ['foo' => 'bar']
 */

$json = $result->getJSON();
/*
 * $json is this:
 * {
 *     "foo": "bar"
 * }
`*/

Puedes usar este método para determinar si $response realmente contiene contenido JSON:

// Verify the response is JSON
$this->assertTrue($result->getJSON() !== false);

Nota

Be aware that the JSON string will be pretty-printed in the result.

afirmarJSONFragment(matriz $fragmento)

Afirma que $fragment se encuentra dentro de la respuesta JSON. No es necesario que coincida con todo el valor JSON.

/*
 * Response body is this:
 * [
 *     'config' => ['key-a', 'key-b'],
 * ]
 */

// Is true
$result->assertJSONFragment(['config' => ['key-a']]);

afirmarJSONExact($prueba)

Similar a assertJSONFragment(), pero verifica la respuesta JSON completa para garantizar coincidencias exactas.

Trabajar con XML

obtener XML()

Si su aplicación devuelve XML, puede recuperarlo mediante este método.