La `RequestValidationError` contient le `body` qu'elle a reçu avec des données invalides.

Vous pouvez l'utiliser pendant le développement de votre application pour journaliser le corps et le déboguer, le renvoyer à l'utilisateur, etc.

{* ../../docs_src/handling_errors/tutorial005_py310.py hl[14] *}

Essayez maintenant d'envoyer un élément invalide comme :

```JSON
{
  "title": "towel",
  "size": "XL"
}
```

Mettez à jour `get_current_user` pour recevoir le même jeton qu'auparavant, mais cette fois en utilisant des jetons JWT.

Décodez le jeton reçu, vérifiez-le, et renvoyez l'utilisateur courant.

Si le jeton est invalide, renvoyez immédiatement une erreur HTTP.

{* ../../docs_src/security/tutorial004_an_py310.py hl[93:110] *}

## Mettre à jour le *chemin d'accès* `/token` { #update-the-token-path-operation }

* authentification HTTP Basic
* HTTP Digest
* format ISO
* la norme JSON Schema
* le schéma JSON
* la définition de schéma
* Flux Password
* Mobile

* déprécié
* conçu
* invalide
* à la volée
* standard
* par défaut
* sensible à la casse
* insensible à la casse

* servir l’application
* servir la page

* l’app
* l’application

* la requête

* **Convertir des données** : de la requête vers le type requis.
* **Valider des données** : provenant de chaque requête :
    * En générant des **erreurs automatiques** renvoyées au client lorsque la donnée est invalide.
* **Documenter** l'API avec OpenAPI :
    * ce qui est ensuite utilisé par les interfaces utilisateur de documentation interactive automatiques.

Cela fonctionnera également car `RedirectResponse` est une sous-classe de `Response`, et FastAPI gérera automatiquement ce cas simple.

### Annotations de type de retour invalides { #invalid-return-type-annotations }

            return false;
        }

        if (!context.isValid()) {
            throw new CIFSException("Preauth integrity context is invalid for session: " + sessionId);
        }

        byte[] actualHash = context.getCurrentHash();
        boolean isValid = MessageDigest.isEqual(actualHash, expectedHash);

        if (isValid) {

        assertTrue(h.isValid());

        // Tree id change makes it invalid
        when(tree.getTreeId()).thenReturn(11L);
        assertFalse(h.isValid());

        // Connected=false makes it invalid
        when(tree.getTreeId()).thenReturn(10L);
        when(tree.isConnected()).thenReturn(false);
        assertFalse(h.isValid());

        // Mark closed makes it invalid

        when(handle.isValid()).thenReturn(true);
        SmbWatchHandleImpl sut = new SmbWatchHandleImpl(handle, 0, false);

        sut.close();

        verify(handle, times(1)).close(0L);
    }

    // close() should do nothing when handle is invalid
    @Test
    @DisplayName("close() does nothing when handle invalid")
    void close_invalidHandle_doesNothing() throws Exception {

errors.invalid_query_unknown = A consulta especificada tem condições desconhecidas.
errors.invalid_query_parse_error = A consulta fornecida é inválida.
errors.invalid_query_sort_value = A ordenação especificada {0} é inválida.
errors.invalid_query_unsupported_sort_field = O campo de ordenação especificado {0} não é suportado.

            fail("Expected CIFSException");
        } catch (CIFSException e) {
            // Expected
        }

        assertFalse(context.isValid());

        // Further operations on invalid context should fail
        assertThrows(CIFSException.class, () -> {
            preauthService.updatePreauthHash(sessionId, "test".getBytes());
        });
    }

    @Test