chore: tiny doc and code consistency fixes (#348)

Author: m4tx

cot-macros/src/dbtest.rs

@@ -16,7 +16,7 @@ pub(super) fn fn_to_dbtest(test_function_decl: ItemFn) -> syn::Result<TokenStrea
     }
 
     let result = quote! {
-        #[::tokio::test]
+        #[::cot::test]
         #[cfg_attr(miri, ignore)] // unsupported operation: can't call foreign function `sqlite3_open_v2`
         async fn #sqlite_ident() {
             let mut database = cot::test::TestDatabase::new_sqlite().await.unwrap();
@@ -29,7 +29,7 @@ pub(super) fn fn_to_dbtest(test_function_decl: ItemFn) -> syn::Result<TokenStrea
         }
 
         #[ignore = "Tests that use PostgreSQL are ignored by default"]
-        #[::tokio::test]
+        #[::cot::test]
         async fn #postgres_ident() {
             let mut database = cot::test::TestDatabase::new_postgres(stringify!(#test_fn))
                 .await
@@ -43,7 +43,7 @@ pub(super) fn fn_to_dbtest(test_function_decl: ItemFn) -> syn::Result<TokenStrea
         }
 
         #[ignore = "Tests that use MySQL are ignored by default"]
-        #[::tokio::test]
+        #[::cot::test]
         async fn #mysql_ident() {
             let mut database = cot::test::TestDatabase::new_mysql(stringify!(#test_fn))
                 .await

cot-macros/src/lib.rs

@@ -195,32 +195,7 @@ pub(crate) fn cot_ident() -> proc_macro2::TokenStream {
         }
     }
 }
-/// A derive macro that automatically implements the [`FromRequestParts`] trait
-/// for structs.
-///
-/// This macro generates code to extract each field of the struct from HTTP
-/// request parts, making it easy to create composite extractors that combine
-/// multiple data sources from an incoming request.
-///
-/// The macro works by calling [`FromRequestParts::from_request_parts`] on each
-/// field's type, allowing you to compose extractors seamlessly. All fields must
-/// implement the [`FromRequestParts`] trait for the derivation to work.
-///
-/// # Examples
-///
-/// ## Named Fields
-///
-/// ```no_run
-/// use cot::request::extractors::{Path, StaticFiles, UrlQuery};
-/// use cot::router::Urls;
-/// use cot_macros::FromRequestParts;
-///
-/// #[derive(Debug, FromRequestParts)]
-/// pub struct BaseContext {
-///     urls: Urls,
-///     static_files: StaticFiles,
-/// }
-/// ```
+
 #[proc_macro_derive(FromRequestParts)]
 pub fn derive_from_request_parts(input: TokenStream) -> TokenStream {
     let ast = parse_macro_input!(input as syn::DeriveInput);

cot/src/admin.rs

@@ -18,12 +18,6 @@ use cot::request::extractors::StaticFiles;
 /// [`Form`] traits. These can also be derived using the `#[model]` and
 /// `#[derive(Form)]` attributes.
 pub use cot_macros::AdminModel;
-/// Implements the [`FromRequestParts`] trait for a struct.
-///
-/// This derive macro allows a struct to be used as a request part extractor.
-/// All fields must implement
-/// [`FromRequestParts`](crate::request::extractors::FromRequestParts), and only
-/// structs are supported (not enums or unions).
 use derive_more::Debug;
 use http::request::Parts;
 use serde::Deserialize;

cot/src/auth.rs

@@ -77,10 +77,9 @@ pub type Result<T> = std::result::Result<T, AuthError>;
 ///
 /// This trait is used to represent a user object that can be authenticated and
 /// is a core of the authentication system. A `User` object is returned by
-/// [`AuthRequestExt::user()`] and is used to check if a user is authenticated
-/// and to access user data. If there is no active user session, the `User`
-/// object returned by [`AuthRequestExt::user()`] is an [`AnonymousUser`]
-/// object.
+/// [`Auth::user()`] and is used to check if a user is authenticated and to
+/// access user data. If there is no active user session, the `User` object
+/// returned by [`Auth::user()`] is an [`AnonymousUser`] object.
 ///
 /// A concrete instance of a `User` object is returned by a backend that
 /// implements the [`AuthBackend`] trait. The default backend is the
@@ -312,8 +311,7 @@ impl Debug for UserWrapper {
 /// An anonymous, unauthenticated user.
 ///
 /// This is used to represent a user that is not authenticated. It is returned
-/// by the [`AuthRequestExt::user()`] method when there is no active user
-/// session.
+/// by the [`Auth::user()`] method when there is no active user session.
 #[derive(Debug, Copy, Clone, Default)]
 pub struct AnonymousUser;
 

cot/src/auth/db.rs

@@ -425,9 +425,8 @@ impl Display for DatabaseUser {
 /// This struct is used to authenticate a user stored in the database. It
 /// contains the username and password of the user.
 ///
-/// Can be passed to
-/// [`AuthRequestExt::authenticate`](crate::auth::AuthRequestExt::authenticate)
-/// to authenticate a user when using the [`DatabaseUserBackend`].
+/// Can be passed to [`Auth::authenticate`](crate::auth::Auth::authenticate) to
+/// authenticate a user when using the [`DatabaseUserBackend`].
 #[derive(Debug, Clone)]
 pub struct DatabaseUserCredentials {
     username: String,

cot/src/common_types.rs

@@ -29,7 +29,7 @@ const MAX_EMAIL_LENGTH: u32 = 254;
 /// the password value.
 ///
 /// For persisting passwords in the database, and verifying passwords against
-/// the hash, use [`PasswordHash`].
+/// the hash, use [`PasswordHash`](crate::auth::PasswordHash).
 ///
 /// # Security
 ///
@@ -40,10 +40,12 @@ const MAX_EMAIL_LENGTH: u32 = 254;
 ///
 /// When comparing passwords, there are two recommended approaches:
 ///
-/// 1. The most secure approach is to use [`PasswordHash::from_password`] to
-///    create a hash from one password, and then use [`PasswordHash::verify`] to
-///    compare it with the other password. This method uses constant-time
-///    equality comparison, which protects against timing attacks.
+/// 1. The most secure approach is to use
+///    [`PasswordHash::from_password`](crate::auth::PasswordHash::from_password)
+///    to create a hash from one password, and then use
+///    [`PasswordHash::verify`](crate::auth::PasswordHash::verify) to compare it
+///    with the other password. This method uses constant-time equality
+///    comparison, which protects against timing attacks.
 ///
 /// 2. An alternative is to use the [`Password::as_str`] method and compare the
 ///    strings directly. This approach uses non-constant-time comparison, which
@@ -135,9 +137,8 @@ impl From<String> for Password {
 
 /// A validated email address.
 ///
-/// This is a newtype wrapper around
-/// [`EmailAddress`](email_address::EmailAddress) that provides validation and
-/// integration with Cot's database system. It ensures email addresses
+/// This is a newtype wrapper around [`EmailAddress`] that provides validation
+/// and integration with Cot's database system. It ensures email addresses
 /// comply with RFC 5321/5322 standards.
 ///
 /// # Examples

cot/src/middleware.rs

@@ -671,7 +671,7 @@ mod tests {
     use crate::session::Session;
     use crate::test::TestRequestBuilder;
 
-    #[tokio::test]
+    #[cot::test]
     async fn session_middleware_adds_session() {
         let svc = tower::service_fn(|req: Request<Body>| async move {
             assert!(req.extensions().get::<Session>().is_some());
@@ -685,7 +685,7 @@ mod tests {
         svc.ready().await.unwrap().call(request).await.unwrap();
     }
 
-    #[tokio::test]
+    #[cot::test]
     async fn session_middleware_adds_cookie() {
         let svc = tower::service_fn(|req: Request<Body>| async move {
             let session = req.extensions().get::<Session>().unwrap();
@@ -713,7 +713,7 @@ mod tests {
         assert!(cookie_value.contains("Path=/"));
     }
 
-    #[tokio::test]
+    #[cot::test]
     async fn session_middleware_adds_cookie_not_secure() {
         let svc = tower::service_fn(|req: Request<Body>| async move {
             let session = req.extensions().get::<Session>().unwrap();
@@ -736,7 +736,7 @@ mod tests {
         assert!(!cookie_value.contains("Secure;"));
     }
 
-    #[tokio::test]
+    #[cot::test]
     async fn auth_middleware_adds_auth() {
         let svc = tower::service_fn(|req: Request<Body>| async move {
             let auth = req
@@ -756,7 +756,7 @@ mod tests {
         svc.ready().await.unwrap().call(request).await.unwrap();
     }
 
-    #[tokio::test]
+    #[cot::test]
     #[should_panic(
         expected = "Session extension missing. Did you forget to add the SessionMiddleware?"
     )]
@@ -773,7 +773,7 @@ mod tests {
         let _result = svc.ready().await.unwrap().call(request).await;
     }
 
-    #[tokio::test]
+    #[cot::test]
     async fn auth_service_cloning() {
         let counter = Arc::new(std::sync::atomic::AtomicUsize::new(0));
         let counter_clone = counter.clone();

cot/src/request.rs

@@ -771,7 +771,7 @@ mod tests {
         assert!(request.expect_content_type("application/json").is_err());
     }
 
-    #[tokio::test]
+    #[cot::test]
     async fn request_ext_extract_parts() {
         async fn handler(mut request: Request) -> Result<Response> {
             let Path(id): Path<String> = request.extract_parts().await?;
@@ -839,7 +839,7 @@ mod tests {
         );
     }
 
-    #[tokio::test]
+    #[cot::test]
     async fn parts_extract_parts() {
         let (mut parts, _) = Request::new(Body::empty()).into_parts();