# Obtener Usuario Actual

En el capítulo anterior, el sistema de seguridad (que se basa en el sistema de inyección de dependencias) le estaba dando a la *path operation function* un `token` como un `str`:

{* ../../docs_src/security/tutorial001_an_py39.py hl[12] *}

Pero eso aún no es tan útil. Vamos a hacer que nos dé el usuario actual.

## Crear un modelo de usuario

Primero, vamos a crear un modelo de usuario con Pydantic.

    private void assertArrayEquals(String[] expected, String[] actual) {
        if (expected == null && actual == null) {
            return;
        }
        assertNotNull("Expected array is null but actual is not", expected);
        assertNotNull("Actual array is null but expected is not", actual);
        assertEquals("Array lengths differ", expected.length, actual.length);
        for (int i = 0; i < expected.length; i++) {

java -jar target/okhttp-tests-*-jar-with-dependencies.jar

jq '.[] as $in | $in | keys[] | . + " " + $in[.].behavior' target/fuzzingserver-report/index.json > target/fuzzingserver-actual.txt

     * @param tc the CIFS context containing credentials
     * @throws CIFSException if an error occurs during authentication
     * @deprecated functionality is broken and will be removed at some point,
     *             use actual Active Directory authentication instead
     */
    @Deprecated
    void logon(CIFSContext tc, Address dc) throws CIFSException;

    /**
     * Authenticate arbitrary credentials represented by the

      assertTrue(
          "index " + i + " expected <" + expected + "., actual is exhausted",
          actualIterator.hasNext());

      Object actual = actualIterator.next();
      assertEquals("index " + i, expected, actual);
      i++;
    }
    if (actualIterator.hasNext()) {
      fail("index " + i + ", expected is exhausted, actual <" + actualIterator.next() + ">");
    }
  }

  /**

import org.junit.runners.JUnit4

actual class PublicSuffixTestRunner(
  klass: Class<*>,
) : Runner() {
  private val delegate = JUnit4(klass)

  override fun getDescription() = delegate.description

  override fun run(notifier: RunNotifier?) = delegate.run(notifier)

  override fun testCount() = delegate.testCount()
}

actual fun beforePublicSuffixTest() {

  }

  private void expectArrayContentsAnyOrder(Object[] expected, Object[] actual) {
    assertEqualIgnoringOrder(asList(expected), asList(actual));
  }

  private void expectArrayContentsInOrder(List<E> expected, Object[] actual) {
    assertEquals("toArray() ordered contents: ", expected, asList(actual));
  }

  /**

        List<String> expected;
        List<String> actual;

        value = "フェス";
        expected = Arrays.asList("フェス");
        actual = Arrays.asList(KuromojiCSVUtil.parse(value));
        assertThat(actual, is(expected));

        value = "フェス,Fess";
        expected = Arrays.asList("フェス", "Fess");
        actual = Arrays.asList(KuromojiCSVUtil.parse(value));
        assertThat(actual, is(expected));

        value = "Fess,フェス";

        int expected = Byte.compare(x, y);
        int actual = SignedBytes.compare(x, y);
        if (expected == 0) {
          assertWithMessage(x + ", " + y).that(actual).isEqualTo(expected);
        } else if (expected < 0) {
          assertWithMessage(x + ", " + y + " (expected: " + expected + ", actual" + actual + ")")
              .that(actual < 0)
              .isTrue();
        } else {

      public int hashCode() {
        return 1;
      }
    }
  }

  private static void assertContains(String expectedSubstring, String actual) {
    // TODO(kevinb): use a Truth assertion here
    if (!actual.contains(expectedSubstring)) {
      fail("expected <" + actual + "> to contain <" + expectedSubstring + ">");
    }
  }