Split db::Connection implementation in submodules (db::user and db::recipe).

backend/src/data/db/recipe.rs

@@ -0,0 +1,125 @@
+use super::{model, Connection, DBError, Result};
+
+impl Connection {
+    pub async fn get_all_recipe_titles(&self) -> Result<Vec<(i64, String)>> {
+        sqlx::query_as("SELECT [id], [title] FROM [Recipe] ORDER BY [title]")
+            .fetch_all(&self.pool)
+            .await
+            .map_err(DBError::from)
+    }
+
+    pub async fn get_recipe(&self, id: i64) -> Result<Option<model::Recipe>> {
+        sqlx::query_as(
+            r#"
+SELECT [id], [user_id], [title], [description]
+FROM [Recipe] WHERE [id] = $1
+            "#,
+        )
+        .bind(id)
+        .fetch_optional(&self.pool)
+        .await
+        .map_err(DBError::from)
+    }
+
+    pub async fn create_recipe(&self, user_id: i64) -> Result<i64> {
+        let mut tx = self.tx().await?;
+
+        match sqlx::query_scalar::<_, i64>(
+            r#"
+SELECT [Recipe].[id] FROM [Recipe]
+LEFT JOIN [Image] ON [Image].[recipe_id] = [Recipe].[id]
+LEFT JOIN [Group] ON [Group].[recipe_id] = [Recipe].[id]
+WHERE [Recipe].[user_id] = $1
+    AND [Recipe].[title] = ''
+    AND [Recipe].[estimate_time] IS NULL
+    AND [Recipe].[description] = ''
+    AND [Image].[id] IS NULL
+    AND [Group].[id] IS NULL
+            "#,
+        )
+        .bind(user_id)
+        .fetch_optional(&mut *tx)
+        .await?
+        {
+            Some(recipe_id) => Ok(recipe_id),
+            None => {
+                let db_result =
+                    sqlx::query("INSERT INTO [Recipe] ([user_id], [title]) VALUES ($1, '')")
+                        .bind(user_id)
+                        .execute(&mut *tx)
+                        .await?;
+
+                tx.commit().await?;
+                Ok(db_result.last_insert_rowid())
+            }
+        }
+    }
+
+    pub async fn set_recipe_title(&self, recipe_id: i64, title: &str) -> Result<()> {
+        sqlx::query("UPDATE [Recipe] SET [title] = $2 WHERE [id] = $1")
+            .bind(recipe_id)
+            .bind(title)
+            .execute(&self.pool)
+            .await
+            .map(|_| ())
+            .map_err(DBError::from)
+    }
+
+    pub async fn set_recipe_description(&self, recipe_id: i64, description: &str) -> Result<()> {
+        sqlx::query("UPDATE [Recipe] SET [description] = $2 WHERE [id] = $1")
+            .bind(recipe_id)
+            .bind(description)
+            .execute(&self.pool)
+            .await
+            .map(|_| ())
+            .map_err(DBError::from)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn create_a_new_recipe_then_update_its_title() -> Result<()> {
+        let connection = Connection::new_in_memory().await?;
+
+        connection.execute_sql(
+            sqlx::query(
+            r#"
+INSERT INTO [User]
+    ([id], [email], [name], [password], [validation_token_datetime], [validation_token])
+VALUES
+    ($1, $2, $3, $4, $5, $6)
+            "#
+            )
+            .bind(1)
+            .bind("paul@atreides.com")
+            .bind("paul")
+            .bind("$argon2id$v=19$m=4096,t=3,p=1$G4fjepS05MkRbTqEImUdYg$GGziE8uVQe1L1oFHk37lBno10g4VISnVqynSkLCH3Lc")
+            .bind("2022-11-29 22:05:04.121407300+00:00")
+            .bind(None::<&str>) // 'null'.
+        ).await?;
+
+        match connection.create_recipe(2).await {
+            Err(DBError::Sqlx(sqlx::Error::Database(err))) => {
+                // SQLITE_CONSTRAINT_FOREIGNKEY
+                // https://www.sqlite.org/rescode.html#constraint_foreignkey
+                assert_eq!(err.code(), Some(std::borrow::Cow::from("787")));
+            } // Nominal case. TODO: check 'err' value.
+            other => panic!(
+                "Creating a recipe with an inexistant user must fail: {:?}",
+                other
+            ),
+        }
+
+        let recipe_id = connection.create_recipe(1).await?;
+        assert_eq!(recipe_id, 1);
+
+        connection.set_recipe_title(recipe_id, "Crêpe").await?;
+        let recipe = connection.get_recipe(recipe_id).await?.unwrap();
+        assert_eq!(recipe.title, "Crêpe".to_string());
+
+        Ok(())
+    }
+}

backend/src/data/db/user.rs

@@ -0,0 +1,945 @@
+use chrono::{prelude::*, Duration};
+use rand::distributions::{Alphanumeric, DistString};
+use sqlx::Sqlite;
+
+use super::{model, Connection, DBError, Result};
+use crate::{
+    consts,
+    hash::{hash, verify_password},
+};
+
+#[derive(Debug)]
+pub enum SignUpResult {
+    UserAlreadyExists,
+    UserCreatedWaitingForValidation(String), // Validation token.
+}
+
+#[derive(Debug)]
+pub enum UpdateUserResult {
+    EmailAlreadyTaken,
+    UserUpdatedWaitingForRevalidation(String), // Validation token.
+    Ok,
+}
+
+#[derive(Debug)]
+pub enum ValidationResult {
+    UnknownUser,
+    ValidationExpired,
+    Ok(String, i64), // Returns token and user id.
+}
+
+#[derive(Debug)]
+pub enum SignInResult {
+    UserNotFound,
+    WrongPassword,
+    AccountNotValidated,
+    Ok(String, i64), // Returns token and user id.
+}
+
+#[derive(Debug)]
+pub enum AuthenticationResult {
+    NotValidToken,
+    Ok(i64), // Returns user id.
+}
+
+#[derive(Debug)]
+pub enum GetTokenResetPasswordResult {
+    PasswordAlreadyReset,
+    EmailUnknown,
+    Ok(String),
+}
+
+#[derive(Debug)]
+pub enum ResetPasswordResult {
+    ResetTokenExpired,
+    Ok,
+}
+
+fn generate_token() -> String {
+    Alphanumeric.sample_string(&mut rand::thread_rng(), consts::TOKEN_SIZE)
+}
+
+impl Connection {
+    #[cfg(test)]
+    pub async fn get_user_login_info(&self, token: &str) -> Result<model::UserLoginInfo> {
+        sqlx::query_as(
+            r#"
+SELECT [last_login_datetime], [ip], [user_agent]
+FROM [UserLoginToken] WHERE [token] = $1
+            "#,
+        )
+        .bind(token)
+        .fetch_one(&self.pool)
+        .await
+        .map_err(DBError::from)
+    }
+
+    pub async fn load_user(&self, user_id: i64) -> Result<Option<model::User>> {
+        sqlx::query_as("SELECT [id], [email], [name] FROM [User] WHERE [id] = $1")
+            .bind(user_id)
+            .fetch_optional(&self.pool)
+            .await
+            .map_err(DBError::from)
+    }
+
+    /// If a new email is given and it doesn't match the current one then it has to be
+    /// Revalidated.
+    pub async fn update_user(
+        &self,
+        user_id: i64,
+        new_email: Option<&str>,
+        new_name: Option<&str>,
+        new_password: Option<&str>,
+    ) -> Result<UpdateUserResult> {
+        let mut tx = self.tx().await?;
+        let hashed_new_password = new_password.map(|p| hash(p).unwrap());
+
+        let (email, name, hashed_password) = sqlx::query_as::<_, (String, String, String)>(
+            "SELECT [email], [name], [password] FROM [User] WHERE [id] = $1",
+        )
+        .bind(user_id)
+        .fetch_one(&mut *tx)
+        .await?;
+
+        let email_changed = new_email.is_some_and(|new_email| new_email != email);
+
+        // Check if email not already taken.
+        let validation_token = if email_changed {
+            if sqlx::query_scalar::<_, i64>(
+                r#"
+SELECT COUNT(*)
+FROM [User]
+WHERE [email] = $1
+                "#,
+            )
+            .bind(new_email.unwrap())
+            .fetch_one(&mut *tx)
+            .await?
+                > 0
+            {
+                return Ok(UpdateUserResult::EmailAlreadyTaken);
+            }
+
+            let token = Some(generate_token());
+            sqlx::query(
+                r#"
+UPDATE [User]
+SET [validation_token] = $2, [validation_token_datetime] = $3
+WHERE [id] = $1
+            "#,
+            )
+            .bind(user_id)
+            .bind(&token)
+            .bind(Utc::now())
+            .execute(&mut *tx)
+            .await?;
+            token
+        } else {
+            None
+        };
+
+        sqlx::query(
+            r#"
+UPDATE [User]
+SET [email] = $2, [name] = $3, [password] = $4
+WHERE [id] = $1
+            "#,
+        )
+        .bind(user_id)
+        .bind(new_email.unwrap_or(&email))
+        .bind(new_name.unwrap_or(&name))
+        .bind(hashed_new_password.unwrap_or(hashed_password))
+        .execute(&mut *tx)
+        .await?;
+
+        tx.commit().await?;
+
+        Ok(if let Some(validation_token) = validation_token {
+            UpdateUserResult::UserUpdatedWaitingForRevalidation(validation_token)
+        } else {
+            UpdateUserResult::Ok
+        })
+    }
+
+    pub async fn sign_up(&self, email: &str, password: &str) -> Result<SignUpResult> {
+        self.sign_up_with_given_time(email, password, Utc::now())
+            .await
+    }
+
+    async fn sign_up_with_given_time(
+        &self,
+        email: &str,
+        password: &str,
+        datetime: DateTime<Utc>,
+    ) -> Result<SignUpResult> {
+        let mut tx = self.tx().await?;
+
+        let token = match sqlx::query_as::<_, (i64, Option<String>)>(
+            r#"
+SELECT [id], [validation_token]
+FROM [User] WHERE [email] = $1
+            "#,
+        )
+        .bind(email)
+        .fetch_optional(&mut *tx)
+        .await?
+        {
+            Some((id, validation_token)) => {
+                if validation_token.is_none() {
+                    return Ok(SignUpResult::UserAlreadyExists);
+                }
+                let token = generate_token();
+                let hashed_password = hash(password).map_err(|e| DBError::from_dyn_error(e))?;
+                sqlx::query(
+                    r#"
+UPDATE [User]
+SET [validation_token] = $2, [validation_token_datetime] = $3, [password] = $4
+WHERE [id] = $1
+                    "#,
+                )
+                .bind(id)
+                .bind(&token)
+                .bind(datetime)
+                .bind(hashed_password)
+                .execute(&mut *tx)
+                .await?;
+                token
+            }
+            None => {
+                let token = generate_token();
+                let hashed_password = hash(password).map_err(|e| DBError::from_dyn_error(e))?;
+                sqlx::query(
+                    r#"
+INSERT INTO [User]
+([email], [validation_token], [validation_token_datetime], [password])
+VALUES ($1, $2, $3, $4)
+                    "#,
+                )
+                .bind(email)
+                .bind(&token)
+                .bind(datetime)
+                .bind(hashed_password)
+                .execute(&mut *tx)
+                .await?;
+                token
+            }
+        };
+
+        tx.commit().await?;
+
+        Ok(SignUpResult::UserCreatedWaitingForValidation(token))
+    }
+
+    pub async fn validation(
+        &self,
+        token: &str,
+        validation_time: Duration,
+        ip: &str,
+        user_agent: &str,
+    ) -> Result<ValidationResult> {
+        let mut tx = self.tx().await?;
+
+        // There is no index on [validation_token]. Is it useful?
+        let user_id = match sqlx::query_as::<_, (i64, DateTime<Utc>)>(
+            "SELECT [id], [validation_token_datetime] FROM [User] WHERE [validation_token] = $1",
+        )
+        .bind(token)
+        .fetch_optional(&mut *tx)
+        .await?
+        {
+            Some((id, validation_token_datetime)) => {
+                if Utc::now() - validation_token_datetime > validation_time {
+                    return Ok(ValidationResult::ValidationExpired);
+                }
+                sqlx::query("UPDATE [User] SET [validation_token] = NULL WHERE [id] = $1")
+                    .bind(id)
+                    .execute(&mut *tx)
+                    .await?;
+                id
+            }
+            None => return Ok(ValidationResult::UnknownUser),
+        };
+
+        let token = Self::create_login_token(&mut tx, user_id, ip, user_agent).await?;
+
+        tx.commit().await?;
+        Ok(ValidationResult::Ok(token, user_id))
+    }
+
+    pub async fn sign_in(
+        &self,
+        email: &str,
+        password: &str,
+        ip: &str,
+        user_agent: &str,
+    ) -> Result<SignInResult> {
+        let mut tx = self.tx().await?;
+        match sqlx::query_as::<_, (i64, String, Option<String>)>(
+            "SELECT [id], [password], [validation_token] FROM [User] WHERE [email] = $1",
+        )
+        .bind(email)
+        .fetch_optional(&mut *tx)
+        .await?
+        {
+            Some((id, stored_password, validation_token)) => {
+                if validation_token.is_some() {
+                    Ok(SignInResult::AccountNotValidated)
+                } else if verify_password(password, &stored_password)
+                    .map_err(DBError::from_dyn_error)?
+                {
+                    let token = Self::create_login_token(&mut tx, id, ip, user_agent).await?;
+                    tx.commit().await?;
+                    Ok(SignInResult::Ok(token, id))
+                } else {
+                    Ok(SignInResult::WrongPassword)
+                }
+            }
+            None => Ok(SignInResult::UserNotFound),
+        }
+    }
+
+    pub async fn authentication(
+        &self,
+        token: &str,
+        ip: &str,
+        user_agent: &str,
+    ) -> Result<AuthenticationResult> {
+        let mut tx = self.tx().await?;
+        match sqlx::query_as::<_, (i64, i64)>(
+            "SELECT [id], [user_id] FROM [UserLoginToken] WHERE [token] = $1",
+        )
+        .bind(token)
+        .fetch_optional(&mut *tx)
+        .await?
+        {
+            Some((login_id, user_id)) => {
+                sqlx::query(
+                    r#"
+UPDATE [UserLoginToken]
+SET [last_login_datetime] = $2, [ip] = $3, [user_agent] = $4
+WHERE [id] = $1
+                    "#,
+                )
+                .bind(login_id)
+                .bind(Utc::now())
+                .bind(ip)
+                .bind(user_agent)
+                .execute(&mut *tx)
+                .await?;
+                tx.commit().await?;
+                Ok(AuthenticationResult::Ok(user_id))
+            }
+            None => Ok(AuthenticationResult::NotValidToken),
+        }
+    }
+
+    pub async fn sign_out(&self, token: &str) -> Result<()> {
+        let mut tx = self.tx().await?;
+        match sqlx::query_scalar::<_, i64>("SELECT [id] FROM [UserLoginToken] WHERE [token] = $1")
+            .bind(token)
+            .fetch_optional(&mut *tx)
+            .await?
+        {
+            Some(login_id) => {
+                sqlx::query("DELETE FROM [UserLoginToken] WHERE [id] = $1")
+                    .bind(login_id)
+                    .execute(&mut *tx)
+                    .await?;
+                tx.commit().await?;
+            }
+            None => (),
+        }
+        Ok(())
+    }
+
+    pub async fn get_token_reset_password(
+        &self,
+        email: &str,
+        validation_time: Duration,
+    ) -> Result<GetTokenResetPasswordResult> {
+        let mut tx = self.tx().await?;
+
+        if let Some(db_datetime_nullable) = sqlx::query_scalar::<_, Option<DateTime<Utc>>>(
+            r#"
+SELECT [password_reset_datetime]
+FROM [User]
+WHERE [email] = $1
+            "#,
+        )
+        .bind(email)
+        .fetch_optional(&mut *tx)
+        .await?
+        {
+            if let Some(db_datetime) = db_datetime_nullable {
+                if Utc::now() - db_datetime <= validation_time {
+                    return Ok(GetTokenResetPasswordResult::PasswordAlreadyReset);
+                }
+            }
+        } else {
+            return Ok(GetTokenResetPasswordResult::EmailUnknown);
+        }
+
+        let token = generate_token();
+
+        sqlx::query(
+            r#"
+UPDATE [User]
+SET [password_reset_token] = $2, [password_reset_datetime] = $3
+WHERE [email] = $1
+            "#,
+        )
+        .bind(email)
+        .bind(&token)
+        .bind(Utc::now())
+        .execute(&mut *tx)
+        .await?;
+
+        tx.commit().await?;
+
+        Ok(GetTokenResetPasswordResult::Ok(token))
+    }
+
+    pub async fn reset_password(
+        &self,
+        new_password: &str,
+        token: &str,
+        validation_time: Duration,
+    ) -> Result<ResetPasswordResult> {
+        let mut tx = self.tx().await?;
+        // There is no index on [password_reset_token]. Is it useful?
+        if let (user_id, Some(db_datetime)) = sqlx::query_as::<_, (i64, Option<DateTime<Utc>>)>(
+            r#"
+SELECT [id], [password_reset_datetime]
+FROM [User]
+WHERE [password_reset_token] = $1
+            "#,
+        )
+        .bind(token)
+        .fetch_one(&mut *tx)
+        .await?
+        {
+            if Utc::now() - db_datetime > validation_time {
+                return Ok(ResetPasswordResult::ResetTokenExpired);
+            }
+
+            // Remove all login tokens (for security reasons).
+            sqlx::query("DELETE FROM [UserLoginToken] WHERE [user_id] = $1")
+                .bind(user_id)
+                .execute(&mut *tx)
+                .await?;
+
+            let hashed_new_password = hash(new_password).map_err(|e| DBError::from_dyn_error(e))?;
+
+            sqlx::query(
+                r#"
+UPDATE [User]
+SET [password] = $2, [password_reset_token] = NULL, [password_reset_datetime] = NULL
+WHERE [id] = $1
+                "#,
+            )
+            .bind(user_id)
+            .bind(hashed_new_password)
+            .execute(&mut *tx)
+            .await?;
+
+            tx.commit().await?;
+
+            Ok(ResetPasswordResult::Ok)
+        } else {
+            Err(DBError::Other(
+                "Can't reset password: stored token or datetime not set (NULL)".to_string(),
+            ))
+        }
+    }
+
+    // Return the token.
+    async fn create_login_token(
+        tx: &mut sqlx::Transaction<'_, Sqlite>,
+        user_id: i64,
+        ip: &str,
+        user_agent: &str,
+    ) -> Result<String> {
+        let token = generate_token();
+        sqlx::query(
+            r#"
+INSERT INTO [UserLoginToken]
+([user_id], [last_login_datetime], [token], [ip], [user_agent])
+VALUES ($1, $2, $3, $4, $5)
+            "#,
+        )
+        .bind(user_id)
+        .bind(Utc::now())
+        .bind(&token)
+        .bind(ip)
+        .bind(user_agent)
+        .execute(&mut **tx)
+        .await?;
+        Ok(token)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn sign_up() -> Result<()> {
+        let connection = Connection::new_in_memory().await?;
+        match connection.sign_up("paul@atreides.com", "12345").await? {
+            SignUpResult::UserCreatedWaitingForValidation(_) => (), // Nominal case.
+            other => panic!("{:?}", other),
+        }
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn sign_up_to_an_already_existing_user() -> Result<()> {
+        let connection = Connection::new_in_memory().await?;
+        connection.execute_sql(
+            sqlx::query(
+            r#"
+INSERT INTO
+    [User] ([id], [email], [name], [password], [validation_token_datetime], [validation_token])
+    VALUES (
+        1,
+        'paul@atreides.com',
+        'paul',
+        '$argon2id$v=19$m=4096,t=3,p=1$1vtXcacYjUHZxMrN6b2Xng$wW8Z59MIoMcsIljnjHmxn3EBcc5ymEySZPUVXHlRxcY',
+        0,
+        NULL
+    );
+            "#)).await?;
+        match connection.sign_up("paul@atreides.com", "12345").await? {
+            SignUpResult::UserAlreadyExists => (), // Nominal case.
+            other => panic!("{:?}", other),
+        }
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn sign_up_and_sign_in_without_validation() -> Result<()> {
+        let connection = Connection::new_in_memory().await?;
+
+        let email = "paul@atreides.com";
+        let password = "12345";
+
+        match connection.sign_up(email, password).await? {
+            SignUpResult::UserCreatedWaitingForValidation(_) => (), // Nominal case.
+            other => panic!("{:?}", other),
+        }
+
+        match connection
+            .sign_in(email, password, "127.0.0.1", "Mozilla/5.0")
+            .await?
+        {
+            SignInResult::AccountNotValidated => (), // Nominal case.
+            other => panic!("{:?}", other),
+        }
+
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn sign_up_to_an_unvalidated_already_existing_user() -> Result<()> {
+        let connection = Connection::new_in_memory().await?;
+        let token = generate_token();
+        connection.execute_sql(
+            sqlx::query(
+            r#"
+INSERT INTO [User]
+    ([id], [email], [name], [password], [validation_token_datetime], [validation_token])
+VALUES (
+    1,
+    'paul@atreides.com',
+    'paul',
+    '$argon2id$v=19$m=4096,t=3,p=1$1vtXcacYjUHZxMrN6b2Xng$wW8Z59MIoMcsIljnjHmxn3EBcc5ymEySZPUVXHlRxcY',
+    0,
+    $1
+)
+            "#
+        ).bind(token)).await?;
+        match connection.sign_up("paul@atreides.com", "12345").await? {
+            SignUpResult::UserCreatedWaitingForValidation(_) => (), // Nominal case.
+            other => panic!("{:?}", other),
+        }
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn sign_up_then_send_validation_at_time() -> Result<()> {
+        let connection = Connection::new_in_memory().await?;
+        let validation_token = match connection.sign_up("paul@atreides.com", "12345").await? {
+            SignUpResult::UserCreatedWaitingForValidation(token) => token, // Nominal case.
+            other => panic!("{:?}", other),
+        };
+        match connection
+            .validation(
+                &validation_token,
+                Duration::hours(1),
+                "127.0.0.1",
+                "Mozilla/5.0",
+            )
+            .await?
+        {
+            ValidationResult::Ok(_, _) => (), // Nominal case.
+            other => panic!("{:?}", other),
+        }
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn sign_up_then_send_validation_too_late() -> Result<()> {
+        let connection = Connection::new_in_memory().await?;
+        let validation_token = match connection
+            .sign_up_with_given_time("paul@atreides.com", "12345", Utc::now() - Duration::days(1))
+            .await?
+        {
+            SignUpResult::UserCreatedWaitingForValidation(token) => token, // Nominal case.
+            other => panic!("{:?}", other),
+        };
+        match connection
+            .validation(
+                &validation_token,
+                Duration::hours(1),
+                "127.0.0.1",
+                "Mozilla/5.0",
+            )
+            .await?
+        {
+            ValidationResult::ValidationExpired => (), // Nominal case.
+            other => panic!("{:?}", other),
+        }
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn sign_up_then_send_validation_with_bad_token() -> Result<()> {
+        let connection = Connection::new_in_memory().await?;
+        let _validation_token = match connection.sign_up("paul@atreides.com", "12345").await? {
+            SignUpResult::UserCreatedWaitingForValidation(token) => token, // Nominal case.
+            other => panic!("{:?}", other),
+        };
+        let random_token = generate_token();
+        match connection
+            .validation(
+                &random_token,
+                Duration::hours(1),
+                "127.0.0.1",
+                "Mozilla/5.0",
+            )
+            .await?
+        {
+            ValidationResult::UnknownUser => (), // Nominal case.
+            other => panic!("{:?}", other),
+        }
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn sign_up_then_send_validation_then_sign_in() -> Result<()> {
+        let connection = Connection::new_in_memory().await?;
+
+        let email = "paul@atreides.com";
+        let password = "12345";
+
+        // Sign up.
+        let validation_token = match connection.sign_up(email, password).await? {
+            SignUpResult::UserCreatedWaitingForValidation(token) => token, // Nominal case.
+            other => panic!("{:?}", other),
+        };
+
+        // Validation.
+        match connection
+            .validation(
+                &validation_token,
+                Duration::hours(1),
+                "127.0.0.1",
+                "Mozilla/5.0",
+            )
+            .await?
+        {
+            ValidationResult::Ok(_, _) => (),
+            other => panic!("{:?}", other),
+        };
+
+        // Sign in.
+        match connection
+            .sign_in(email, password, "127.0.0.1", "Mozilla/5.0")
+            .await?
+        {
+            SignInResult::Ok(_, _) => (), // Nominal case.
+            other => panic!("{:?}", other),
+        }
+
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn sign_up_then_send_validation_then_authentication() -> Result<()> {
+        let connection = Connection::new_in_memory().await?;
+
+        let email = "paul@atreides.com";
+        let password = "12345";
+
+        // Sign up.
+        let validation_token = match connection.sign_up(email, password).await? {
+            SignUpResult::UserCreatedWaitingForValidation(token) => token, // Nominal case.
+            other => panic!("{:?}", other),
+        };
+
+        // Validation.
+        let (authentication_token, _user_id) = match connection
+            .validation(
+                &validation_token,
+                Duration::hours(1),
+                "127.0.0.1",
+                "Mozilla",
+            )
+            .await?
+        {
+            ValidationResult::Ok(token, user_id) => (token, user_id),
+            other => panic!("{:?}", other),
+        };
+
+        // Check user login information.
+        let user_login_info_1 = connection
+            .get_user_login_info(&authentication_token)
+            .await?;
+        assert_eq!(user_login_info_1.ip, "127.0.0.1");
+        assert_eq!(user_login_info_1.user_agent, "Mozilla");
+
+        // Authentication.
+        let _user_id = match connection
+            .authentication(&authentication_token, "192.168.1.1", "Chrome")
+            .await?
+        {
+            AuthenticationResult::Ok(user_id) => user_id, // Nominal case.
+            other => panic!("{:?}", other),
+        };
+
+        // Check user login information.
+        let user_login_info_2 = connection
+            .get_user_login_info(&authentication_token)
+            .await?;
+
+        assert_eq!(user_login_info_2.ip, "192.168.1.1");
+        assert_eq!(user_login_info_2.user_agent, "Chrome");
+
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn sign_up_then_send_validation_then_sign_out_then_sign_in() -> Result<()> {
+        let connection = Connection::new_in_memory().await?;
+
+        let email = "paul@atreides.com";
+        let password = "12345";
+
+        // Sign up.
+        let validation_token = match connection.sign_up(email, password).await? {
+            SignUpResult::UserCreatedWaitingForValidation(token) => token, // Nominal case.
+            other => panic!("{:?}", other),
+        };
+
+        // Validation.
+        let (authentication_token_1, user_id_1) = match connection
+            .validation(
+                &validation_token,
+                Duration::hours(1),
+                "127.0.0.1",
+                "Mozilla",
+            )
+            .await?
+        {
+            ValidationResult::Ok(token, user_id) => (token, user_id),
+            other => panic!("{:?}", other),
+        };
+
+        // Check user login information.
+        let user_login_info_1 = connection
+            .get_user_login_info(&authentication_token_1)
+            .await?;
+        assert_eq!(user_login_info_1.ip, "127.0.0.1");
+        assert_eq!(user_login_info_1.user_agent, "Mozilla");
+
+        // Sign out.
+        connection.sign_out(&authentication_token_1).await?;
+
+        // Sign in.
+        let (authentication_token_2, user_id_2) = match connection
+            .sign_in(email, password, "192.168.1.1", "Chrome")
+            .await?
+        {
+            SignInResult::Ok(token, user_id) => (token, user_id),
+            other => panic!("{:?}", other),
+        };
+
+        assert_eq!(user_id_1, user_id_2);
+        assert_ne!(authentication_token_1, authentication_token_2);
+
+        // Check user login information.
+        let user_login_info_2 = connection
+            .get_user_login_info(&authentication_token_2)
+            .await?;
+
+        assert_eq!(user_login_info_2.ip, "192.168.1.1");
+        assert_eq!(user_login_info_2.user_agent, "Chrome");
+
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn ask_to_reset_password_for_unknown_email() -> Result<()> {
+        let connection = Connection::new_in_memory().await?;
+
+        let email = "paul@atreides.com";
+
+        // Ask for password reset.
+        match connection
+            .get_token_reset_password(email, Duration::hours(1))
+            .await?
+        {
+            GetTokenResetPasswordResult::EmailUnknown => Ok(()), // Nominal case.
+            other => panic!("{:?}", other),
+        }
+    }
+
+    #[tokio::test]
+    async fn sign_up_then_send_validation_then_sign_out_then_ask_to_reset_password() -> Result<()> {
+        let connection = Connection::new_in_memory().await?;
+
+        let email = "paul@atreides.com";
+        let password = "12345";
+        let new_password = "54321";
+
+        // Sign up.
+        let validation_token = match connection.sign_up(email, password).await? {
+            SignUpResult::UserCreatedWaitingForValidation(token) => token, // Nominal case.
+            other => panic!("{:?}", other),
+        };
+
+        // Validation.
+        let (authentication_token_1, user_id_1) = match connection
+            .validation(
+                &validation_token,
+                Duration::hours(1),
+                "127.0.0.1",
+                "Mozilla",
+            )
+            .await?
+        {
+            ValidationResult::Ok(token, user_id) => (token, user_id),
+            other => panic!("{:?}", other),
+        };
+
+        // Check user login information.
+        let user_login_info_1 = connection
+            .get_user_login_info(&authentication_token_1)
+            .await?;
+        assert_eq!(user_login_info_1.ip, "127.0.0.1");
+        assert_eq!(user_login_info_1.user_agent, "Mozilla");
+
+        // Sign out.
+        connection.sign_out(&authentication_token_1).await?;
+
+        // Ask for password reset.
+        let token = match connection
+            .get_token_reset_password(email, Duration::hours(1))
+            .await?
+        {
+            GetTokenResetPasswordResult::Ok(token) => token,
+            other => panic!("{:?}", other),
+        };
+
+        connection
+            .reset_password(&new_password, &token, Duration::hours(1))
+            .await?;
+
+        // Sign in.
+        let (authentication_token_2, user_id_2) = match connection
+            .sign_in(email, new_password, "192.168.1.1", "Chrome")
+            .await?
+        {
+            SignInResult::Ok(token, user_id) => (token, user_id),
+            other => panic!("{:?}", other),
+        };
+
+        assert_eq!(user_id_1, user_id_2);
+        assert_ne!(authentication_token_1, authentication_token_2);
+
+        // Check user login information.
+        let user_login_info_2 = connection
+            .get_user_login_info(&authentication_token_2)
+            .await?;
+
+        assert_eq!(user_login_info_2.ip, "192.168.1.1");
+        assert_eq!(user_login_info_2.user_agent, "Chrome");
+
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn update_user() -> Result<()> {
+        let connection = Connection::new_in_memory().await?;
+
+        connection.execute_sql(
+            sqlx::query(
+            r#"
+INSERT INTO [User]
+    ([id], [email], [name], [password], [validation_token_datetime], [validation_token])
+VALUES
+    ($1, $2, $3, $4, $5, $6)
+            "#
+            )
+            .bind(1)
+            .bind("paul@atreides.com")
+            .bind("paul")
+            .bind("$argon2id$v=19$m=4096,t=3,p=1$G4fjepS05MkRbTqEImUdYg$GGziE8uVQe1L1oFHk37lBno10g4VISnVqynSkLCH3Lc")
+            .bind("2022-11-29 22:05:04.121407300+00:00")
+            .bind(None::<&str>) // 'null'.
+        ).await?;
+
+        let user = connection.load_user(1).await?.unwrap();
+
+        assert_eq!(user.name, "paul");
+        assert_eq!(user.email, "paul@atreides.com");
+
+        if let UpdateUserResult::UserUpdatedWaitingForRevalidation(token) = connection
+            .update_user(
+                1,
+                Some("muaddib@fremen.com"),
+                Some("muaddib"),
+                Some("Chani"),
+            )
+            .await?
+        {
+            let (_authentication_token_1, user_id_1) = match connection
+                .validation(&token, Duration::hours(1), "127.0.0.1", "Mozilla/5.0")
+                .await?
+            {
+                ValidationResult::Ok(token, user_id) => (token, user_id),
+                other => panic!("{:?}", other),
+            };
+            assert_eq!(user_id_1, 1);
+        } else {
+            panic!("A revalidation token must be created when changin e-mail");
+        }
+
+        let user = connection.load_user(1).await?.unwrap();
+
+        assert_eq!(user.name, "muaddib");
+        assert_eq!(user.email, "muaddib@fremen.com");
+
+        // Tests if password has been updated correctly.
+        if let SignInResult::Ok(_token, id) = connection
+            .sign_in("muaddib@fremen.com", "Chani", "127.0.0.1", "Mozilla/5.0")
+            .await?
+        {
+            assert_eq!(id, 1);
+        } else {
+            panic!("Can't sign in");
+        }
+
+        Ok(())
+    }
+}