│   └── test_main.py
```

The file `main.py` would have:

```Python
{!../../../docs_src/async_tests/main.py!}
```

The file `test_main.py` would have the tests for `main.py`, it could look like this now:

```Python
{!../../../docs_src/async_tests/test_main.py!}
```

## Run it

You can run your tests as usual via:

<div class="termy">

```console
$ pytest

---> 100%
```

</div>

-e .[all]
-r requirements-docs-tests.txt
pytest >=7.1.3,<8.0.0
coverage[toml] >= 6.5.0,< 8.0
mypy ==1.8.0
ruff ==0.2.0
dirty-equals ==0.6.0
# TODO: once removing databases from tutorial, upgrade SQLAlchemy
# probably when including SQLModel
sqlalchemy >=1.3.18,<1.4.43
databases[sqlite] >=0.3.2,<0.7.0
flask >=1.1.2,<3.0.0
anyio[trio] >=3.2.1,<4.0.0
python-jose[cryptography] >=3.3.0,<4.0.0
pyyaml >=5.3.1,<7.0.0
passlib[bcrypt] >=1.7.2,<2.0.0

    testImplementation(projectTests(":compiler:tests-common"))
    testApi(projectTests(":compiler:test-infrastructure-utils"))
    testApi(projectTests(":compiler:test-infrastructure"))
    testImplementation(projectTests(":compiler:tests-common-new"))
    testImplementation(projectTests(":compiler:fir:analysis-tests:legacy-fir-tests"))
    testImplementation(projectTests(":analysis:analysis-api-impl-base"))

### Documentation pour les tests

La plupart des tests sont en fait effectués par rapport aux exemples de fichiers sources dans la documentation.

Cela permet de s'assurer que :

* La documentation est à jour.
* Les exemples de documentation peuvent être exécutés tels quels.
* La plupart des fonctionnalités sont couvertes par la documentation, assurées par la couverture des tests.

        group = "verification"
        description = "Runs the cross-version tests against all Gradle versions with 'forking' executer"
    }

    val quickFeedbackCrossVersionTests = tasks.register("quickFeedbackCrossVersionTests") {
        group = "verification"
        description = "Runs the cross-version tests against a subset of selected Gradle versions with 'forking' executer for quick feedback"
    }

**4. Approved**

-   Once the PR is approved, it gets `kokoro:force-run` label applied and it
    initiates CI/CD tests.
-   We can't move forward if these tests fail.
-   In such situations, we may request you to make further changes to your PR
    for the tests to pass.
-   Once the tests pass, we now bring all the code into the internal code base,
    using a job called "copybara".

Para esto es recomendable primero añadir tests a tu aplicación.

Con **FastAPI** es muy fácil (gracias a Starlette), revisa la documentación [Testing](../tutorial/testing.md){.internal-link target=_blank}

Luego de tener los tests, puedes actualizar la versión de **FastAPI** a una más reciente y asegurarte de que tu código funciona correctamente ejecutando los tests.

            skipConditionally()
        }
    }

    fun BuildSteps.adHocPerformanceTest(tests: List<String>) {
        gradleStep(
            listOf(
                "clean",
                "performance:${testProject}PerformanceAdHocTest",
                tests.map { """--tests "$it"""" }.joinToString(" "),
                """--warmups 2 --runs 2 --checks none""",

    val testNameParameterName = "testName"
    val testTaskOptionsParameterName = "testTaskOptions"
    val daemon = true
    applyDefaultSettings(os, arch, buildJvm = BuildToolBuildJvm, timeout = 0)

    // Show all failed tests here, since that is what we are interested in
    failureConditions.supportTestRetry = false

import mockwebserver3.MockWebServer
import okhttp3.ExperimentalOkHttpApi
import org.junit.rules.ExternalResource

/**
 * Runs MockWebServer for the duration of a single test method.
 *
 * In Java JUnit 4 tests (ie. tests annotated `@org.junit.Test`), use this by defining a field with
 * the `@Rule` annotation:
 *
 * ```java
 * @Rule public final MockWebServerRule serverRule = new MockWebServerRule();
 * ```
 *