{% set refs = fields | filter(attribute="is_ref", value=true) %}use std::sync::Arc;
use dominio_{{ snake }}::modelo::Id{{ pascal }};
{% for import in reference_imports %}use {{ import }};
{% endfor %}use aplicacion_{{ snake }}::{
crear_{{ snake }}::{ParamsCrear{{ pascal }}, Crear{{ pascal }}},
borrar_{{ snake }}::{ParamsBorrar{{ pascal }}, Borrar{{ pascal }}},
obtener_{{ snake }}::{ParamsObtener{{ pascal }}, Obtener{{ pascal }}},
listar_{{ plural }}::{ParamsListar{{ plural_pascal }}, Listar{{ plural_pascal }}},
actualizar_{{ snake }}::{ParamsActualizar{{ pascal }}, Actualizar{{ pascal }}},
};
use poem_openapi::{
OpenApi, Tags,
param::{Path, Query},
payload::Json,
};
use puerto_nucleo::PeticionPagina;
{% if bearer and optional_auth %}use puerto_web::auth::{BearerAuth, BearerAuthOpcional};
{% elif bearer %}use puerto_web::auth::BearerAuth;
{% elif optional_auth %}use puerto_web::auth::BearerAuthOpcional;
{% endif %}{% if any_role %}use puerto_web::requiere_rol;
{% endif %}use uuid::Uuid;
use crate::dto::{
PeticionCrear{{ pascal }}, PeticionActualizar{{ pascal }}, Dto{{ pascal }}, DtoPagina{{ pascal }},
};
use crate::errores::a_respuesta_error;
use crate::respuestas::{
RespuestaCrear{{ pascal }}, RespuestaBorrar{{ pascal }}, RespuestaObtener{{ pascal }}, RespuestaListar{{ plural_pascal }},
RespuestaActualizar{{ pascal }},
};
#[derive(Tags)]
enum ApiTags {
{{ pascal }},
}
/// Guarda los puertos de los casos de uso; `generado/bootstrap.rs` conecta las implementaciones.
pub struct Api{{ pascal }} {
pub crear_{{ snake }}: Arc<dyn Crear{{ pascal }}>,
pub obtener_{{ snake }}: Arc<dyn Obtener{{ pascal }}>,
pub listar_{{ plural }}: Arc<dyn Listar{{ plural_pascal }}>,
pub actualizar_{{ snake }}: Arc<dyn Actualizar{{ pascal }}>,
pub borrar_{{ snake }}: Arc<dyn Borrar{{ pascal }}>,
}
#[OpenApi]
impl Api{{ pascal }} {
/// Crea: {{ pascal }}
#[oai(path = "/{{ plural }}", method = "post", tag = "ApiTags::{{ pascal }}")]
{% for role in access.create.roles %} #[requiere_rol("{{ role }}")]
{% endfor %} async fn crear(&self, {% if access.create.protected %}auth: BearerAuth, {% elif access.create.optional %}auth: BearerAuthOpcional, {% endif %}cuerpo: Json<PeticionCrear{{ pascal }}>) -> RespuestaCrear{{ pascal }} {
match self
.crear_{{ snake }}
.ejecutar(ParamsCrear{{ pascal }} {
{% if access.create.protected %} actor: auth.0,
{% endif %}{% for f in fields %} {{ f.name }}: {{ f.from_body }},
{% endfor %} })
.await
{
Ok(entidad) => RespuestaCrear{{ pascal }}::Creado(Json({% if access.create.optional %}dto(&auth, &entidad){% else %}Dto{{ pascal }}::from_dominio(&entidad){% endif %})),
Err(err) => {
let (status, error) = a_respuesta_error(err);
tracing::warn!(codigo = %error.0.codigo, "crear_{{ snake }} falló");
RespuestaCrear{{ pascal }}::from_status(status, error)
}
}
}
/// Obtiene: {{ pascal }} por id
#[oai(path = "/{{ plural }}/:id", method = "get", tag = "ApiTags::{{ pascal }}")]
{% for role in access.get.roles %} #[requiere_rol("{{ role }}")]
{% endfor %} async fn obtener(&self, {% if access.get.protected %}auth: BearerAuth, {% elif access.get.optional %}auth: BearerAuthOpcional, {% endif %}id: Path<Uuid>) -> RespuestaObtener{{ pascal }} {
match self
.obtener_{{ snake }}
.ejecutar(ParamsObtener{{ pascal }} { {% if access.get.protected %}actor: auth.0, {% endif %}id: Id{{ pascal }}::from_uuid(id.0) })
.await
{
Ok(entidad) => RespuestaObtener{{ pascal }}::Ok(Json({% if access.get.optional %}dto(&auth, &entidad){% else %}Dto{{ pascal }}::from_dominio(&entidad){% endif %})),
Err(err) => {
let (status, error) = a_respuesta_error(err);
tracing::warn!(codigo = %error.0.codigo, "obtener_{{ snake }} falló");
RespuestaObtener{{ pascal }}::from_status(status, error)
}
}
}
/// Lista {{ plural_pascal }}, página a página (el dominio acota `limite`)
#[oai(path = "/{{ plural }}", method = "get", tag = "ApiTags::{{ pascal }}")]
{% for role in access.list.roles %} #[requiere_rol("{{ role }}")]
{% endfor %} async fn listar(&self, {% if access.list.protected %}auth: BearerAuth, {% elif access.list.optional %}auth: BearerAuthOpcional, {% endif %}limite: Query<Option<u32>>, desplazamiento: Query<Option<u32>>{% for r in refs %}, #[oai(name = "{{ r.camel }}")] {{ r.name }}: Query<Option<Uuid>>{% endfor %}) -> RespuestaListar{{ plural_pascal }} {
match self
.listar_{{ plural }}
.ejecutar(ParamsListar{{ plural_pascal }} {
{% if access.list.protected %} actor: auth.0,
{% endif %} pagina: PeticionPagina::new(limite.0, desplazamiento.0),
{% for r in refs %} {{ r.name }}: {{ r.name }}.0.map(Id{{ r.ref_target }}::from_uuid),
{% endfor %} })
.await
{
Ok(pagina) => RespuestaListar{{ plural_pascal }}::Ok(Json({% if access.list.optional %}if auth.0.is_some() {
DtoPagina{{ pascal }}::from_dominio(&pagina)
} else {
DtoPagina{{ pascal }}::from_dominio_publico(&pagina)
}{% else %}DtoPagina{{ pascal }}::from_dominio(&pagina){% endif %})),
Err(err) => {
let (status, error) = a_respuesta_error(err);
tracing::error!(codigo = %error.0.codigo, "listar_{{ plural }} falló");
RespuestaListar{{ plural_pascal }}::from_status(status, error)
}
}
}
/// Actualiza: {{ pascal }}
#[oai(path = "/{{ plural }}/:id", method = "put", tag = "ApiTags::{{ pascal }}")]
{% for role in access.update.roles %} #[requiere_rol("{{ role }}")]
{% endfor %} async fn actualizar(&self, {% if access.update.protected %}auth: BearerAuth, {% elif access.update.optional %}auth: BearerAuthOpcional, {% endif %}id: Path<Uuid>, cuerpo: Json<PeticionActualizar{{ pascal }}>) -> RespuestaActualizar{{ pascal }} {
match self
.actualizar_{{ snake }}
.ejecutar(ParamsActualizar{{ pascal }} {
{% if access.update.protected %} actor: auth.0,
{% endif %} id: Id{{ pascal }}::from_uuid(id.0),
{% for f in fields %} {{ f.name }}: {{ f.from_body }},
{% endfor %} })
.await
{
Ok(entidad) => RespuestaActualizar{{ pascal }}::Ok(Json({% if access.update.optional %}dto(&auth, &entidad){% else %}Dto{{ pascal }}::from_dominio(&entidad){% endif %})),
Err(err) => {
let (status, error) = a_respuesta_error(err);
tracing::warn!(codigo = %error.0.codigo, "actualizar_{{ snake }} falló");
RespuestaActualizar{{ pascal }}::from_status(status, error)
}
}
}
/// Borra: {{ pascal }}
#[oai(path = "/{{ plural }}/:id", method = "delete", tag = "ApiTags::{{ pascal }}")]
{% for role in access.delete.roles %} #[requiere_rol("{{ role }}")]
{% endfor %} async fn borrar(&self, {% if access.delete.protected %}auth: BearerAuth, {% endif %}id: Path<Uuid>) -> RespuestaBorrar{{ pascal }} {
match self
.borrar_{{ snake }}
.ejecutar(ParamsBorrar{{ pascal }} { {% if access.delete.protected %}actor: auth.0, {% endif %}id: Id{{ pascal }}::from_uuid(id.0) })
.await
{
Ok(()) => RespuestaBorrar{{ pascal }}::SinContenido,
Err(err) => {
let (status, error) = a_respuesta_error(err);
tracing::warn!(codigo = %error.0.codigo, "borrar_{{ snake }} falló");
RespuestaBorrar{{ pascal }}::from_status(status, error)
}
}
}
}
{% if access.create.optional or access.get.optional or access.update.optional %}/// La entidad entera a quien tiene sesión; sin los campos privados a quien no la tiene.
fn dto(auth: &BearerAuthOpcional, entidad: &dominio_{{ snake }}::modelo::{{ pascal }}) -> Dto{{ pascal }} {
if auth.0.is_some() {
Dto{{ pascal }}::from_dominio(entidad)
} else {
Dto{{ pascal }}::from_dominio_publico(entidad)
}
}
{% endif %}#[cfg(test)]
mod tests {
use dominio_{{ snake }}::errores::Error{{ pascal }};
use aplicacion_{{ snake }}::{
crear_{{ snake }}::dobles::MockCrear{{ pascal }}, borrar_{{ snake }}::dobles::MockBorrar{{ pascal }},
obtener_{{ snake }}::dobles::MockObtener{{ pascal }}, listar_{{ plural }}::dobles::MockListar{{ plural_pascal }},
actualizar_{{ snake }}::dobles::MockActualizar{{ pascal }},
};
use dominio_{{ snake }}::pruebas::madres::Madre{{ pascal }};{% if auth %}
use puerto_nucleo::auth::dobles::MadrePrincipal;
use poem::{EndpointExt, Route, http::StatusCode, test::TestClient};
use puerto_nucleo::auth::dobles::MockAutenticador;
use puerto_nucleo::auth::{ErrorAuth, Autenticador};{% else %}
use poem::{Route, http::StatusCode, test::TestClient};{% endif %}
use poem_openapi::{OpenApiService, types::ToJSON};
use puerto_nucleo::Pagina;{% for import in test_imports %}
use {{ import }};{% endfor %}
use super::*;
/// Un doble por caso de uso. Cada test pone expectativas solo en el que su ruta debe llamar:
/// una ruta que recurra a otro caso de uso entra en pánico en vez de pasar.
#[derive(Default)]
struct Dobles {
crear: MockCrear{{ pascal }},
obtener: MockObtener{{ pascal }},
listar: MockListar{{ plural_pascal }},
actualizar: MockActualizar{{ pascal }},
borrar: MockBorrar{{ pascal }},
}
{% if auth %} /// Acepta `llamante` (con todos los roles que pide alguna ruta de esta API) y `nadie`
/// (sin roles).
fn autenticador() -> Arc<dyn Autenticador> {
let mut doble = MockAutenticador::new();
doble.expect_autenticar().returning(|token| match token {
"llamante" => Ok({% if caller_roles %}MadrePrincipal::new()
.con_roles([{% for role in caller_roles %}"{{ role }}"{% if not loop.last %}, {% endif %}{% endfor %}])
.construir(){% else %}MadrePrincipal::aleatorio(){% endif %}),
"nadie" => Ok(MadrePrincipal::aleatorio()),
_ => Err(ErrorAuth::Invalido),
});
Arc::new(doble)
}
{% endif %} impl Dobles {
{% if auth %} /// Todas las peticiones, con sesión iniciada como `llamante`.
fn cliente(self) -> TestClient<impl poem::Endpoint> {
self.cliente_con(Some("Bearer llamante"))
}
/// `autorizacion`: la cabecera que envía cada petición; con `None` no se envía ninguna.
fn cliente_con(self, autorizacion: Option<&str>) -> TestClient<impl poem::Endpoint> {
{% else %} fn cliente(self) -> TestClient<Route> {
{% endif %} let api = Api{{ pascal }} {
crear_{{ snake }}: Arc::new(self.crear),
obtener_{{ snake }}: Arc::new(self.obtener),
listar_{{ plural }}: Arc::new(self.listar),
actualizar_{{ snake }}: Arc::new(self.actualizar),
borrar_{{ snake }}: Arc::new(self.borrar),
};
{% if auth %} let cliente = TestClient::new(
Route::new()
.nest("/", OpenApiService::new(api, "test", "1.0"))
.data(autenticador()),
);
match autorizacion {
Some(valor) => cliente.default_header("Authorization", valor),
None => cliente,
}
{% else %} TestClient::new(Route::new().nest("/", OpenApiService::new(api, "test", "1.0")))
{% endif %} }
}
fn peticion_crear() -> PeticionCrear{{ pascal }} {
PeticionCrear{{ pascal }} {
{% for f in fields %} {{ f.name }}: {{ f.default_literal }},
{% endfor %} }
}
fn peticion_actualizar() -> PeticionActualizar{{ pascal }} {
PeticionActualizar{{ pascal }} {
{% for f in fields %} {{ f.name }}: {{ f.default_literal }},
{% endfor %} }
}
fn ruta_elemento() -> String {
format!("/{{ plural }}/{}", Uuid::new_v4())
}
#[tokio::test]
async fn deberia_responder_201_cuando_se_crea_{{ snake }}() {
// Preparar
let mut dobles = Dobles::default();
dobles.crear.expect_ejecutar().returning(|_| Ok(Madre{{ pascal }}::aleatorio()));
// Actuar
let respuesta = dobles
.cliente()
.post("/{{ plural }}")
.body_json(&peticion_crear().to_json())
.send()
.await;
// Comprobar
respuesta.assert_status(StatusCode::CREATED);
}
#[tokio::test]
async fn deberia_responder_422_cuando_{{ snake }}_no_supera_la_validacion() {
// Preparar
let mut dobles = Dobles::default();
dobles
.crear
.expect_ejecutar()
.returning(|_| Err(Error{{ pascal }}::Validacion("invalid".to_string())));
// Actuar
let respuesta = dobles
.cliente()
.post("/{{ plural }}")
.body_json(&peticion_crear().to_json())
.send()
.await;
// Comprobar
respuesta.assert_status(StatusCode::UNPROCESSABLE_ENTITY);
}
{% for f in fields | filter(attribute="is_ref", value=true) %}
#[tokio::test]
async fn deberia_responder_422_cuando_no_existe_la_referencia_de_{{ f.name }}() {
// Preparar: en la base de datos no hay {{ f.ref_target }} con ese id (ADR-0022 de Puerto).
let mut dobles = Dobles::default();
dobles.crear.expect_ejecutar().returning(|_| {
Err(Error{{ pascal }}::Validacion("{{ f.name }}_no_encontrado".to_string()))
});
// Actuar
let respuesta = dobles
.cliente()
.post("/{{ plural }}")
.body_json(&peticion_crear().to_json())
.send()
.await;
// Comprobar
respuesta.assert_status(StatusCode::UNPROCESSABLE_ENTITY);
respuesta
.json()
.await
.value()
.object()
.get("codigo")
.assert_string("{{ snake }}.validacion.{{ f.name }}_no_encontrado");
}
{% endfor %}
#[tokio::test]
async fn deberia_responder_200_cuando_{{ snake }}_existe() {
// Preparar
let mut dobles = Dobles::default();
dobles.obtener.expect_ejecutar().returning(|_| Ok(Madre{{ pascal }}::aleatorio()));
// Actuar
let respuesta = dobles.cliente().get(ruta_elemento()).send().await;
// Comprobar
respuesta.assert_status(StatusCode::OK);
}
{% if access.get.optional %}
#[tokio::test]
async fn deberia_ocultar_los_campos_privados_a_quien_llama_sin_sesion() {
// Preparar
let mut dobles = Dobles::default();
dobles.obtener.expect_ejecutar().returning(|_| Ok(Madre{{ pascal }}::aleatorio()));
// Actuar
let respuesta = dobles.cliente_con(None).get(ruta_elemento()).send().await;
// Comprobar
respuesta.assert_status(StatusCode::OK);
let cuerpo = respuesta.json().await;
{% for camel in private_fields %} assert!(cuerpo.value().object().get_opt("{{ camel }}").is_none());
{% endfor %} }
#[tokio::test]
async fn deberia_mostrar_los_campos_privados_a_quien_tiene_sesion() {
// Preparar
let mut dobles = Dobles::default();
dobles.obtener.expect_ejecutar().returning(|_| Ok(Madre{{ pascal }}::aleatorio()));
// Actuar
let respuesta = dobles.cliente().get(ruta_elemento()).send().await;
// Comprobar
respuesta.assert_status(StatusCode::OK);
let cuerpo = respuesta.json().await;
{% for camel in private_fields %} assert!(cuerpo.value().object().get_opt("{{ camel }}").is_some());
{% endfor %} }
{% endif %}
#[tokio::test]
async fn deberia_responder_404_cuando_{{ snake }}_no_existe() {
// Preparar
let mut dobles = Dobles::default();
dobles.obtener.expect_ejecutar().returning(|_| Err(Error{{ pascal }}::NoEncontrado));
// Actuar
let respuesta = dobles.cliente().get(ruta_elemento()).send().await;
// Comprobar
respuesta.assert_status(StatusCode::NOT_FOUND);
}
#[tokio::test]
async fn deberia_responder_200_con_una_pagina_de_{{ plural }}_cuando_se_listan() {
// Preparar
let mut dobles = Dobles::default();
dobles
.listar
.expect_ejecutar()
.returning(|params| Ok(Pagina::new(Madre{{ pascal }}::aleatorios(2), 7, params.pagina)));
// Actuar
let respuesta = dobles.cliente().get("/{{ plural }}").send().await;
// Comprobar
respuesta.assert_status(StatusCode::OK);
let json = respuesta.json().await;
let cuerpo = json.value().object();
cuerpo.get("elementos").array().assert_len(2);
cuerpo.get("total").assert_i64(7);
}
#[tokio::test]
async fn deberia_pasar_limite_y_desplazamiento_al_caso_de_uso() {
// Preparar
let mut dobles = Dobles::default();
dobles
.listar
.expect_ejecutar()
.withf(|params| params.pagina == PeticionPagina::new(Some(5), Some(10)))
.returning(|params| Ok(Pagina::new(vec![], 0, params.pagina)));
// Actuar
let respuesta = dobles.cliente().get("/{{ plural }}?limite=5&desplazamiento=10").send().await;
// Comprobar
respuesta.assert_status(StatusCode::OK);
}
{% for r in refs %} #[tokio::test]
async fn deberia_pasar_el_filtro_por_{{ r.name }}_al_caso_de_uso() {
// Preparar
let {{ r.name }} = Uuid::new_v4();
let mut dobles = Dobles::default();
dobles
.listar
.expect_ejecutar()
.withf(move |params| params.{{ r.name }} == Some(Id{{ r.ref_target }}::from_uuid({{ r.name }})))
.returning(|params| Ok(Pagina::new(vec![], 0, params.pagina)));
// Actuar
let respuesta = dobles.cliente().get(format!("/{{ plural }}?{{ r.camel }}={{ "{" }}{{ r.name }}}")).send().await;
// Comprobar
respuesta.assert_status(StatusCode::OK);
}
{% endfor %} #[tokio::test]
async fn deberia_responder_500_cuando_el_listado_falla_en_el_repositorio() {
// Preparar
let mut dobles = Dobles::default();
dobles.listar.expect_ejecutar().returning(|_| Err(Error{{ pascal }}::Repositorio));
// Actuar
let respuesta = dobles.cliente().get("/{{ plural }}").send().await;
// Comprobar
respuesta.assert_status(StatusCode::INTERNAL_SERVER_ERROR);
}
#[tokio::test]
async fn deberia_responder_200_cuando_se_actualiza_{{ snake }}() {
// Preparar
let mut dobles = Dobles::default();
dobles.actualizar.expect_ejecutar().returning(|_| Ok(Madre{{ pascal }}::aleatorio()));
// Actuar
let respuesta = dobles
.cliente()
.put(ruta_elemento())
.body_json(&peticion_actualizar().to_json())
.send()
.await;
// Comprobar
respuesta.assert_status(StatusCode::OK);
}
#[tokio::test]
async fn deberia_responder_404_cuando_se_actualiza_{{ snake }}_inexistente() {
// Preparar
let mut dobles = Dobles::default();
dobles.actualizar.expect_ejecutar().returning(|_| Err(Error{{ pascal }}::NoEncontrado));
// Actuar
let respuesta = dobles
.cliente()
.put(ruta_elemento())
.body_json(&peticion_actualizar().to_json())
.send()
.await;
// Comprobar
respuesta.assert_status(StatusCode::NOT_FOUND);
}
#[tokio::test]
async fn deberia_responder_204_cuando_se_borra_{{ snake }}() {
// Preparar
let mut dobles = Dobles::default();
dobles.borrar.expect_ejecutar().returning(|_| Ok(()));
// Actuar
let respuesta = dobles.cliente().delete(ruta_elemento()).send().await;
// Comprobar
respuesta.assert_status(StatusCode::NO_CONTENT);
}
#[tokio::test]
async fn deberia_responder_404_cuando_se_borra_{{ snake }}_inexistente() {
// Preparar
let mut dobles = Dobles::default();
dobles.borrar.expect_ejecutar().returning(|_| Err(Error{{ pascal }}::NoEncontrado));
// Actuar
let respuesta = dobles.cliente().delete(ruta_elemento()).send().await;
// Comprobar
respuesta.assert_status(StatusCode::NOT_FOUND);
}
{% if access.create.protected %}
#[tokio::test]
async fn deberia_responder_401_cuando_se_crea_sin_token() {
// Preparar — sin expectativas: nunca se llega al caso de uso
let dobles = Dobles::default();
// Actuar
let respuesta = dobles
.cliente_con(None)
.post("/{{ plural }}")
.body_json(&peticion_crear().to_json())
.send()
.await;
// Comprobar
respuesta.assert_status(StatusCode::UNAUTHORIZED);
}
{% endif %}{% if access.create.roles %}
#[tokio::test]
async fn deberia_responder_403_cuando_se_crea_sin_el_rol() {
// Preparar — sin expectativas: nunca se llega al caso de uso
let dobles = Dobles::default();
// Actuar
let respuesta = dobles
.cliente_con(Some("Bearer nadie"))
.post("/{{ plural }}")
.body_json(&peticion_crear().to_json())
.send()
.await;
// Comprobar
respuesta.assert_status(StatusCode::FORBIDDEN);
respuesta
.json()
.await
.value()
.object()
.get("codigo")
.assert_string("auth.prohibido");
}
{% endif %}{% if access.get.protected %}
#[tokio::test]
async fn deberia_responder_401_cuando_se_obtiene_sin_token() {
// Preparar — sin expectativas: nunca se llega al caso de uso
let dobles = Dobles::default();
// Actuar
let respuesta = dobles
.cliente_con(None)
.get(ruta_elemento())
.send()
.await;
// Comprobar
respuesta.assert_status(StatusCode::UNAUTHORIZED);
}
{% endif %}{% if access.get.roles %}
#[tokio::test]
async fn deberia_responder_403_cuando_se_obtiene_sin_el_rol() {
// Preparar — sin expectativas: nunca se llega al caso de uso
let dobles = Dobles::default();
// Actuar
let respuesta = dobles
.cliente_con(Some("Bearer nadie"))
.get(ruta_elemento())
.send()
.await;
// Comprobar
respuesta.assert_status(StatusCode::FORBIDDEN);
respuesta
.json()
.await
.value()
.object()
.get("codigo")
.assert_string("auth.prohibido");
}
{% endif %}{% if access.list.protected %}
#[tokio::test]
async fn deberia_responder_401_cuando_se_lista_sin_token() {
// Preparar — sin expectativas: nunca se llega al caso de uso
let dobles = Dobles::default();
// Actuar
let respuesta = dobles
.cliente_con(None)
.get("/{{ plural }}")
.send()
.await;
// Comprobar
respuesta.assert_status(StatusCode::UNAUTHORIZED);
}
{% endif %}{% if access.list.roles %}
#[tokio::test]
async fn deberia_responder_403_cuando_se_lista_sin_el_rol() {
// Preparar — sin expectativas: nunca se llega al caso de uso
let dobles = Dobles::default();
// Actuar
let respuesta = dobles
.cliente_con(Some("Bearer nadie"))
.get("/{{ plural }}")
.send()
.await;
// Comprobar
respuesta.assert_status(StatusCode::FORBIDDEN);
respuesta
.json()
.await
.value()
.object()
.get("codigo")
.assert_string("auth.prohibido");
}
{% endif %}{% if access.update.protected %}
#[tokio::test]
async fn deberia_responder_401_cuando_se_actualiza_sin_token() {
// Preparar — sin expectativas: nunca se llega al caso de uso
let dobles = Dobles::default();
// Actuar
let respuesta = dobles
.cliente_con(None)
.put(ruta_elemento())
.body_json(&peticion_actualizar().to_json())
.send()
.await;
// Comprobar
respuesta.assert_status(StatusCode::UNAUTHORIZED);
}
{% endif %}{% if access.update.roles %}
#[tokio::test]
async fn deberia_responder_403_cuando_se_actualiza_sin_el_rol() {
// Preparar — sin expectativas: nunca se llega al caso de uso
let dobles = Dobles::default();
// Actuar
let respuesta = dobles
.cliente_con(Some("Bearer nadie"))
.put(ruta_elemento())
.body_json(&peticion_actualizar().to_json())
.send()
.await;
// Comprobar
respuesta.assert_status(StatusCode::FORBIDDEN);
respuesta
.json()
.await
.value()
.object()
.get("codigo")
.assert_string("auth.prohibido");
}
{% endif %}{% if access.delete.protected %}
#[tokio::test]
async fn deberia_responder_401_cuando_se_borra_sin_token() {
// Preparar — sin expectativas: nunca se llega al caso de uso
let dobles = Dobles::default();
// Actuar
let respuesta = dobles
.cliente_con(None)
.delete(ruta_elemento())
.send()
.await;
// Comprobar
respuesta.assert_status(StatusCode::UNAUTHORIZED);
}
{% endif %}{% if access.delete.roles %}
#[tokio::test]
async fn deberia_responder_403_cuando_se_borra_sin_el_rol() {
// Preparar — sin expectativas: nunca se llega al caso de uso
let dobles = Dobles::default();
// Actuar
let respuesta = dobles
.cliente_con(Some("Bearer nadie"))
.delete(ruta_elemento())
.send()
.await;
// Comprobar
respuesta.assert_status(StatusCode::FORBIDDEN);
respuesta
.json()
.await
.value()
.object()
.get("codigo")
.assert_string("auth.prohibido");
}
{% endif %}}