import java.nio.charset.StandardCharsets;

import org.junit.jupiter.api.Test;

class AvTargetNameTest {

    /**
     * Test constructor with raw bytes.
     * Verifies that the AvPair type is correctly set and raw bytes are stored.
     */
    @Test
    void testConstructorWithRawBytes() {
        byte[] rawBytes = "TEST_TARGET_NAME".getBytes(StandardCharsets.UTF_16LE);

        ntlmRequest = new NtlmHttpServletRequest(mockRequest, mockPrincipal);
    }

    /**
     * Test method for {@link NtlmHttpServletRequest#getRemoteUser()}.
     * Verifies that the method returns the name of the principal.
     */
    @Test
    void testGetRemoteUser() {
        // Arrange: Define the expected user name from the principal
        String expectedUserName = "testUser";

comportement, où le code d’arrêt des dépendances avec `yield` s’exécute avant l’envoi de la réponse.

Par exemple, imaginez que vous ayez du code qui utilise une session de base de données dans une dépendance avec `yield` uniquement pour vérifier un utilisateur, mais que la session de base de données ne soit plus jamais utilisée dans la *fonction de chemin d'accès*, seulement dans la dépendance, et que la réponse mette longtemps à être envoyée, comme une `StreamingResponse` qui envoie les...

    @Before
    public void before() throws Exception {
        runner.admin().indices().prepareDelete("_all").execute().actionGet();
    }

    /**
     * Test getIndicesForAlias method with existing alias.
     * Verifies that the method correctly retrieves indices for a given alias.
     */
    @Test
    @SuppressWarnings("unchecked")
    public void testGetIndicesForAlias_existingAlias() throws Exception {

<img src="/img/tutorial/security/image12.png">

## Vérifier le nom d'utilisateur { #check-the-username }

Voici un exemple plus complet.

Utilisez une dépendance pour vérifier si le nom d'utilisateur et le mot de passe sont corrects.

Pour cela, utilisez le module standard Python [`secrets`](https://docs.python.org/3/library/secrets.html) pour vérifier le nom d'utilisateur et le mot de passe.

 */
public class RankFusionProcessorConcurrencyTest extends UnitFessTestCase {

    private static final String ID_FIELD = "_id";

    /**
     * Test concurrent registration of searchers from multiple threads.
     * Verifies that CopyOnWriteArrayList handles concurrent modifications safely.
     */
    @Test
    public void test_concurrentSearcherRegistration() throws Exception {
        final int numThreads = 10;

Vous pouvez le vérifier sur [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs) :

<img src="/img/tutorial/behind-a-proxy/image01.png">

Mais si nous accédons à l'interface de documents à l'URL « officielle » en utilisant le proxy avec le port `9999`, à `/api/v1/docs`, cela fonctionne correctement ! 🎉

    }
  }

  /**
   * Skips coalescing when hostname verifier is overridden since the intention of the hostname
   * verification is a black box.
   */
  @Test
  fun skipsWhenHostnameVerifierUsed() {
    val verifier = HostnameVerifier { name: String?, session: SSLSession? -> true }
    client = client.newBuilder().hostnameVerifier(verifier).build()
    server.enqueue(MockResponse())
    server.enqueue(MockResponse())

Pour l'erreur, nous utilisons l'exception `HTTPException` :

{* ../../docs_src/security/tutorial003_an_py310.py hl[3,79:81] *}

### Vérifier le mot de passe { #check-the-password }

À ce stade, nous avons les données utilisateur depuis notre base, mais nous n'avons pas encore vérifié le mot de passe.

Mettons d'abord ces données dans le modèle Pydantic `UserInDB`.

      nullableValueEntry.setValue(null);
      fail("setValue on unmodifiable Map.Entry succeeded");
    } catch (UnsupportedOperationException expected) {
    }
  }

  /**
   * Verifies that an Iterator is unmodifiable.
   *
   * <p>This test only works with iterators that iterate over a finite set.
   */
  public static void assertIteratorIsUnmodifiable(Iterator<?> iterator) {