- [ ] Provide integration tests (under `<subproject>/src/integTest`) to verify changes from a user perspective.
- [ ] Provide unit tests (under `<subproject>/src/test`) to verify logic.
- [ ] Update User Guide, DSL Reference, and Javadoc for public-facing changes.
- [ ] Ensure that tests pass sanity check: `./gradlew sanityCheck`.
- [ ] Ensure that tests pass locally: `./gradlew <changed-subproject>:quickTest`.

Y puedes usar cualquier modelo o datos para los requisitos de seguridad (en este caso, un modelo de Pydantic `User`).

Pero no estás limitado a usar algún modelo de datos, clase o tipo específico.

¿Quieres tener un `id` y `email` y no tener un `username` en tu modelo? Claro. Puedes usar estas mismas herramientas.

		},
	}
	for k, result := range results {
		v, ok := constraints[k]
		if !ok {
			t.Errorf("Failed to found unique constraint %v from parsed constraints %+v", k, constraints)
		}
		tests.AssertObjEqual(t, result, v, "Name")
		tests.AssertObjEqual(t, result.Field, v.Field, "Name", "Unique", "UniqueIndex")
	}

## `OAuth2PasswordBearer` de **FastAPI** { #fastapis-oauth2passwordbearer }

**FastAPI** proporciona varias herramientas, en diferentes niveles de abstracción, para implementar estas funcionalidades de seguridad.

En este ejemplo vamos a usar **OAuth2**, con el flujo **Password**, usando un token **Bearer**. Hacemos eso utilizando la clase `OAuth2PasswordBearer`.

/// info | Información

		},
	}
	for _, tt := range tests {
		t.Run(tt.want, func(t *testing.T) {
			if got := tt.arn.String(); got != tt.want {
				t.Errorf("ARN.String() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestNewIAMRoleARN(t *testing.T) {
	type args struct {
		resourceID   string
		serverRegion string
	}
	tests := []struct {
		name    string
		args    args
		want    ARN

Usando estas ideas, JWT puede ser utilizado para escenarios mucho más sofisticados.

En esos casos, varias de esas entidades podrían tener el mismo ID, digamos `foo` (un usuario `foo`, un coche `foo`, y un artículo del blog `foo`).

Cuando necesitas que `lifespan` se ejecute en tus tests, puedes usar el `TestClient` con un statement `with`:

{* ../../docs_src/app_testing/tutorial004_py39.py hl[9:15,18,27:28,30:32,41:43] *}


Puedes leer más detalles sobre ["Ejecutar lifespan en tests en el sitio oficial de documentación de Starlette."](https://www.starlette.dev/lifespan/#running-lifespan-in-tests)

| <<<test-jar>>>        | <<<tests>>>   | <<<jar>>>  | java      | classes, patch module |                       |
*-----------------------+---------------+------------+-----------+-----------------------+-----------------------+
| <<<modular-jar>>> *   | <<<tests>>>   | <<<jar>>>  | java      | modules               |                       |

You should add tests for your app.

With **FastAPI** it's very easy (thanks to Starlette), check the docs: [Testing](../tutorial/testing.md){.internal-link target=_blank}

After you have tests, then you can upgrade the **FastAPI** version to a more recent one, and make sure that all your code is working correctly by running your tests.

aspects of a component while ignoring others.

These stubs form an internally consistent data-set that is not expected to change. They are
used to test the individual components in the lifecycle with data that has expected characteristics
and can be asserted as desired.

You can change/extend these stubs, and tests should not be breaking too much, since most tests